Function pingSuspendedRoot

lib/assets/react-source/development/react.js:26654–26705

(root, thenable, suspendedTime)

	  }
	}
	function pingSuspendedRoot(root, thenable, suspendedTime) {
	  var pingCache = root.pingCache;

	  if (pingCache !== null) {
	    // The thenable resolved, so we no longer need to memoize, because it will
	    // never be thrown again.
	    pingCache.delete(thenable);
	  }

	  if (workInProgressRoot === root && renderExpirationTime$1 === suspendedTime) {
	    // Received a ping at the same priority level at which we're currently
	    // rendering. We might want to restart this render. This should mirror
	    // the logic of whether or not a root suspends once it completes.
	    // TODO: If we're rendering sync either due to Sync, Batched or expired,
	    // we should probably never restart.
	    // If we're suspended with delay, we'll always suspend so we can always
	    // restart. If we're suspended without any updates, it might be a retry.
	    // If it's early in the retry we can restart. We can't know for sure
	    // whether we'll eventually process an update during this render pass,
	    // but it's somewhat unlikely that we get to a ping before that, since
	    // getting to the root most update is usually very fast.
	    if (workInProgressRootExitStatus === RootSuspendedWithDelay || workInProgressRootExitStatus === RootSuspended && workInProgressRootLatestProcessedExpirationTime === Sync && now() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS) {
	      // Restart from the root. Don't need to schedule a ping because
	      // we're already working on this tree.
	      prepareFreshStack(root, renderExpirationTime$1);
	    } else {
	      // Even though we can't restart right now, we might get an
	      // opportunity later. So we mark this render as having a ping.
	      workInProgressRootHasPendingPing = true;
	    }

	    return;
	  }

	  if (!isRootSuspendedAtTime(root, suspendedTime)) {
	    // The root is no longer suspended at this time.
	    return;
	  }

	  var lastPingedTime = root.lastPingedTime;

	  if (lastPingedTime !== NoWork && lastPingedTime < suspendedTime) {
	    // There's already a lower priority ping scheduled.
	    return;
	  } // Mark the time at which this ping was scheduled.


	  root.lastPingedTime = suspendedTime;

	  ensureRootIsScheduled(root);
	  schedulePendingInteractions(root, suspendedTime);
	}

	function retryTimedOutBoundary(boundaryFiber, retryTime) {
	  // The boundary fiber (a Suspense component or SuspenseList component)