Function finishConcurrentRender

docs/external/js/react-dom.development.js:21638–21857

(root, finishedWork, exitStatus, expirationTime)

  }

  function finishConcurrentRender(root, finishedWork, exitStatus, expirationTime) {
    // Set this to null to indicate there's no in-progress render.
    workInProgressRoot = null;

    switch (exitStatus) {
      case RootIncomplete:
      case RootFatalErrored:
        {
          {
            {
              throw Error( "Root did not complete. This is a bug in React." );
            }
          }
        }
      // Flow knows about invariant, so it complains if I add a break
      // statement, but eslint doesn't know about invariant, so it complains
      // if I do. eslint-disable-next-line no-fallthrough

      case RootErrored:
        {
          // If this was an async render, the error may have happened due to
          // a mutation in a concurrent event. Try rendering one more time,
          // synchronously, to see if the error goes away. If there are
          // lower priority updates, let's include those, too, in case they
          // fix the inconsistency. Render at Idle to include all updates.
          // If it was Idle or Never or some not-yet-invented time, render
          // at that time.
          markRootExpiredAtTime(root, expirationTime > Idle ? Idle : expirationTime); // We assume that this second render pass will be synchronous
          // and therefore not hit this path again.

          break;
        }

      case RootSuspended:
        {
          markRootSuspendedAtTime(root, expirationTime);
          var lastSuspendedTime = root.lastSuspendedTime;

          if (expirationTime === lastSuspendedTime) {
            root.nextKnownPendingLevel = getRemainingExpirationTime(finishedWork);
          } // We have an acceptable loading state. We need to figure out if we
          // should immediately commit it or wait a bit.
          // If we have processed new updates during this render, we may now
          // have a new loading state ready. We want to ensure that we commit
          // that as soon as possible.


          var hasNotProcessedNewUpdates = workInProgressRootLatestProcessedExpirationTime === Sync;

          if (hasNotProcessedNewUpdates && // do not delay if we're inside an act() scope
          !( IsThisRendererActing.current)) {
            // If we have not processed any new updates during this pass, then
            // this is either a retry of an existing fallback state or a
            // hidden tree. Hidden trees shouldn't be batched with other work
            // and after that's fixed it can only be a retry. We're going to
            // throttle committing retries so that we don't show too many
            // loading states too quickly.
            var msUntilTimeout = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now(); // Don't bother with a very short suspense time.