Function updateSuspenseComponent

lib/assets/react-source/development/react.js:21310–21567

(current, workInProgress, renderExpirationTime)

	}

	function updateSuspenseComponent(current, workInProgress, renderExpirationTime) {
	  var mode = workInProgress.mode;
	  var nextProps = workInProgress.pendingProps; // This is used by DevTools to force a boundary to suspend.

	  {
	    if (shouldSuspend(workInProgress)) {
	      workInProgress.effectTag |= DidCapture;
	    }
	  }

	  var suspenseContext = suspenseStackCursor.current;
	  var nextDidTimeout = false;
	  var didSuspend = (workInProgress.effectTag & DidCapture) !== NoEffect;

	  if (didSuspend || shouldRemainOnFallback(suspenseContext, current)) {
	    // Something in this boundary's subtree already suspended. Switch to
	    // rendering the fallback children.
	    nextDidTimeout = true;
	    workInProgress.effectTag &= ~DidCapture;
	  } else {
	    // Attempting the main content
	    if (current === null || current.memoizedState !== null) {
	      // This is a new mount or this boundary is already showing a fallback state.
	      // Mark this subtree context as having at least one invisible parent that could
	      // handle the fallback state.
	      // Boundaries without fallbacks or should be avoided are not considered since
	      // they cannot handle preferred fallback states.
	      if (nextProps.fallback !== undefined && nextProps.unstable_avoidThisFallback !== true) {
	        suspenseContext = addSubtreeSuspenseContext(suspenseContext, InvisibleParentSuspenseContext);
	      }
	    }
	  }

	  suspenseContext = setDefaultShallowSuspenseContext(suspenseContext);
	  pushSuspenseContext(workInProgress, suspenseContext); // This next part is a bit confusing. If the children timeout, we switch to
	  // showing the fallback children in place of the "primary" children.
	  // However, we don't want to delete the primary children because then their
	  // state will be lost (both the React state and the host state, e.g.
	  // uncontrolled form inputs). Instead we keep them mounted and hide them.
	  // Both the fallback children AND the primary children are rendered at the
	  // same time. Once the primary children are un-suspended, we can delete
	  // the fallback children — don't need to preserve their state.
	  //
	  // The two sets of children are siblings in the host environment, but
	  // semantically, for purposes of reconciliation, they are two separate sets.
	  // So we store them using two fragment fibers.
	  //
	  // However, we want to avoid allocating extra fibers for every placeholder.
	  // They're only necessary when the children time out, because that's the
	  // only time when both sets are mounted.
	  //
	  // So, the extra fragment fibers are only used if the children time out.
	  // Otherwise, we render the primary children directly. This requires some
	  // custom reconciliation logic to preserve the state of the primary
	  // children. It's essentially a very basic form of re-parenting.

	  if (current === null) {
	    // If we're currently hydrating, try to hydrate this boundary.