react-test-renderer 18.2.0 → 18.3.0-next-522f47345-20220614

package/cjs/react-test-renderer.development.js

@@ -3570,7 +3570,13 @@ function enqueueConcurrentRenderForLane(fiber, lane) {
 var unsafe_markUpdateLaneFromFiberToRoot = markUpdateLaneFromFiberToRoot;
 
 function markUpdateLaneFromFiberToRoot(sourceFiber, lane) {
-  // Update the source fiber's lanes
+  // TODO: We will detect and infinite update loop and throw even if this fiber
+  // has already unmounted. This isn't really necessary but it happens to be the
+  // current behavior we've used for several release cycles. Consider not
+  // performing this check if the updated fiber already unmounted, since it's
+  // not possible for that to cause an infinite update loop.
+  throwIfInfiniteUpdateLoopDetected(); // Update the source fiber's lanes
+
   sourceFiber.lanes = mergeLanes(sourceFiber.lanes, lane);
   var alternate = sourceFiber.alternate;
 
@@ -4627,7 +4633,7 @@ function mountClassInstance(workInProgress, ctor, newProps, renderLanes) {
   }
 
   if (typeof instance.componentDidMount === 'function') {
-    var fiberFlags = Update;
+    var fiberFlags = Update | LayoutStatic;
 
     workInProgress.flags |= fiberFlags;
   }
@@ -4671,7 +4677,7 @@ function resumeMountClassInstance(workInProgress, ctor, newProps, renderLanes) {
     // If an update was already in progress, we should schedule an Update
     // effect even though we're bailing out, so that cWU/cDU are called.
     if (typeof instance.componentDidMount === 'function') {
-      var fiberFlags = Update;
+      var fiberFlags = Update | LayoutStatic;
 
       workInProgress.flags |= fiberFlags;
     }
@@ -4700,7 +4706,7 @@ function resumeMountClassInstance(workInProgress, ctor, newProps, renderLanes) {
     }
 
     if (typeof instance.componentDidMount === 'function') {
-      var _fiberFlags = Update;
+      var _fiberFlags = Update | LayoutStatic;
 
       workInProgress.flags |= _fiberFlags;
     }
@@ -4708,7 +4714,7 @@ function resumeMountClassInstance(workInProgress, ctor, newProps, renderLanes) {
     // If an update was already in progress, we should schedule an Update
     // effect even though we're bailing out, so that cWU/cDU are called.
     if (typeof instance.componentDidMount === 'function') {
-      var _fiberFlags2 = Update;
+      var _fiberFlags2 = Update | LayoutStatic;
 
       workInProgress.flags |= _fiberFlags2;
     } // If shouldComponentUpdate returned false, we should still update the
@@ -7122,7 +7128,7 @@ function updateInsertionEffect(create, deps) {
 }
 
 function mountLayoutEffect(create, deps) {
-  var fiberFlags = Update;
+  var fiberFlags = Update | LayoutStatic;
 
   return mountEffectImpl(fiberFlags, Layout, create, deps);
 }
@@ -7168,7 +7174,7 @@ function mountImperativeHandle(ref, create, deps) {
 
 
   var effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
-  var fiberFlags = Update;
+  var fiberFlags = Update | LayoutStatic;
 
   return mountEffectImpl(fiberFlags, Layout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
 }
@@ -9450,6 +9456,7 @@ function markRef(current, workInProgress) {
   if (current === null && ref !== null || current !== null && current.ref !== ref) {
     // Schedule a Ref effect
     workInProgress.flags |= Ref;
+    workInProgress.flags |= RefStatic;
   }
 }
 
@@ -11440,7 +11447,7 @@ function markUpdate(workInProgress) {
 }
 
 function markRef$1(workInProgress) {
-  workInProgress.flags |= Ref;
+  workInProgress.flags |= Ref | RefStatic;
 }
 
 var appendAllChildren;
@@ -12448,6 +12455,10 @@ function unwindWork(current, workInProgress, renderLanes) {
 
       return null;
 
+    case TracingMarkerComponent:
+
+      return null;
+
     default:
       return null;
   }
@@ -12724,6 +12735,11 @@ var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
 {
   didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
 } // Used during the commit phase to track the state of the Offscreen component stack.
+// Allows us to avoid traversing the return path to find the nearest Offscreen ancestor.
+
+
+var offscreenSubtreeIsHidden = false;
+var offscreenSubtreeWasHidden = false;
 var PossiblyWeakSet = typeof WeakSet === 'function' ? WeakSet : Set;
 var nextEffect = null; // Used for Profiling builds to track updaters.
 function reportUncaughtErrorInDEV(error) {
@@ -12757,6 +12773,15 @@ var callComponentWillUnmountWithTimer = function (current, instance) {
 }; // Capture errors so they don't interrupt mounting.
 
 
+function safelyCallCommitHookLayoutEffectListMount(current, nearestMountedAncestor) {
+  try {
+    commitHookEffectListMount(Layout, current);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+} // Capture errors so they don't interrupt unmounting.
+
+
 function safelyCallComponentWillUnmount(current, nearestMountedAncestor, instance) {
   try {
     callComponentWillUnmountWithTimer(current, instance);
@@ -12765,6 +12790,24 @@ function safelyCallComponentWillUnmount(current, nearestMountedAncestor, instanc
   }
 } // Capture errors so they don't interrupt mounting.
 
+
+function safelyCallComponentDidMount(current, nearestMountedAncestor, instance) {
+  try {
+    instance.componentDidMount();
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+} // Capture errors so they don't interrupt mounting.
+
+
+function safelyAttachRef(current, nearestMountedAncestor) {
+  try {
+    commitAttachRef(current);
+  } catch (error) {
+    captureCommitPhaseError(current, nearestMountedAncestor, error);
+  }
+}
+
 function safelyDetachRef(current, nearestMountedAncestor) {
   var ref = current.ref;
 
@@ -13098,7 +13141,7 @@ function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork, committe
       case ForwardRef:
       case SimpleMemoComponent:
         {
-          {
+          if (!offscreenSubtreeWasHidden) {
             // At this point layout effects have already been destroyed (during mutation phase).
             // This is done to prevent sibling component effects from interfering with each other,
             // e.g. a destroy function in one component should never override a ref set
@@ -13123,7 +13166,7 @@ function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork, committe
           var instance = finishedWork.stateNode;
 
           if (finishedWork.flags & Update) {
-            {
+            if (!offscreenSubtreeWasHidden) {
               if (current === null) {
                 // We could update instance props and state here,
                 // but instead we rely on them being set during last render.
@@ -13336,7 +13379,7 @@ function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork, committe
     }
   }
 
-  {
+  if (!offscreenSubtreeWasHidden) {
     {
       if (finishedWork.flags & Ref) {
         commitAttachRef(finishedWork);
@@ -13345,6 +13388,48 @@ function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork, committe
   }
 }
 
+function reappearLayoutEffectsOnFiber(node) {
+  // Turn on layout effects in a tree that previously disappeared.
+  // TODO (Offscreen) Check: flags & LayoutStatic
+  switch (node.tag) {
+    case FunctionComponent:
+    case ForwardRef:
+    case SimpleMemoComponent:
+      {
+        if ( node.mode & ProfileMode) {
+          try {
+            startLayoutEffectTimer();
+            safelyCallCommitHookLayoutEffectListMount(node, node.return);
+          } finally {
+            recordLayoutEffectDuration(node);
+          }
+        } else {
+          safelyCallCommitHookLayoutEffectListMount(node, node.return);
+        }
+
+        break;
+      }
+
+    case ClassComponent:
+      {
+        var instance = node.stateNode;
+
+        if (typeof instance.componentDidMount === 'function') {
+          safelyCallComponentDidMount(node, node.return, instance);
+        }
+
+        safelyAttachRef(node, node.return);
+        break;
+      }
+
+    case HostComponent:
+      {
+        safelyAttachRef(node, node.return);
+        break;
+      }
+  }
+}
+
 function hideOrUnhideAllChildren(finishedWork, isHidden) {
   // Only hide or unhide the top-most host nodes.
   var hostSubtreeRoot = null;
@@ -13790,7 +13875,7 @@ function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, dele
   switch (deletedFiber.tag) {
     case HostComponent:
       {
-        {
+        if (!offscreenSubtreeWasHidden) {
           safelyDetachRef(deletedFiber, nearestMountedAncestor);
         } // Intentional fallthrough to next branch
 
@@ -13863,7 +13948,7 @@ function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, dele
     case MemoComponent:
     case SimpleMemoComponent:
       {
-        {
+        if (!offscreenSubtreeWasHidden) {
           var updateQueue = deletedFiber.updateQueue;
 
           if (updateQueue !== null) {
@@ -13905,7 +13990,7 @@ function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, dele
 
     case ClassComponent:
       {
-        {
+        if (!offscreenSubtreeWasHidden) {
           safelyDetachRef(deletedFiber, nearestMountedAncestor);
           var instance = deletedFiber.stateNode;
 
@@ -13927,7 +14012,21 @@ function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, dele
 
     case OffscreenComponent:
       {
-        {
+        if (deletedFiber.mode & ConcurrentMode) {
+          // If this offscreen component is hidden, we already unmounted it. Before
+          // deleting the children, track that it's already unmounted so that we
+          // don't attempt to unmount the effects again.
+          // TODO: If the tree is hidden, in most cases we should be able to skip
+          // over the nested children entirely. An exception is we haven't yet found
+          // the topmost host node to delete, which we already track on the stack.
+          // But the other case is portals, which need to be detached no matter how
+          // deeply they are nested. We should use a subtree flag to track whether a
+          // subtree includes a nested portal.
+          var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || deletedFiber.memoizedState !== null;
+          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        } else {
           recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);
         }
 
@@ -14217,7 +14316,15 @@ function commitMutationEffectsOnFiber(finishedWork, root, lanes) {
       {
         var _wasHidden = current !== null && current.memoizedState !== null;
 
-        {
+        if (finishedWork.mode & ConcurrentMode) {
+          // Before committing the children, track on the stack whether this
+          // offscreen subtree was already hidden, so that we don't unmount the
+          // effects again.
+          var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || _wasHidden;
+          recursivelyTraverseMutationEffects(root, finishedWork);
+          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        } else {
           recursivelyTraverseMutationEffects(root, finishedWork);
         }
 
@@ -14234,6 +14341,21 @@ function commitMutationEffectsOnFiber(finishedWork, root, lanes) {
 
           _offscreenInstance.isHidden = _isHidden;
 
+          if (_isHidden) {
+            if (!_wasHidden) {
+              if ((offscreenBoundary.mode & ConcurrentMode) !== NoMode) {
+                nextEffect = offscreenBoundary;
+                var offscreenChild = offscreenBoundary.child;
+
+                while (offscreenChild !== null) {
+                  nextEffect = offscreenChild;
+                  disappearLayoutEffects_begin(offscreenChild);
+                  offscreenChild = offscreenChild.sibling;
+                }
+              }
+            }
+          }
+
           {
             // TODO: This needs to run whenever there's an insertion or update
             // inside a hidden Offscreen tree.
@@ -14309,6 +14431,51 @@ function commitLayoutEffects_begin(subtreeRoot, root, committedLanes) {
     var fiber = nextEffect;
     var firstChild = fiber.child;
 
+    if (fiber.tag === OffscreenComponent && isModernRoot) {
+      // Keep track of the current Offscreen stack's state.
+      var isHidden = fiber.memoizedState !== null;
+      var newOffscreenSubtreeIsHidden = isHidden || offscreenSubtreeIsHidden;
+
+      if (newOffscreenSubtreeIsHidden) {
+        // The Offscreen tree is hidden. Skip over its layout effects.
+        commitLayoutMountEffects_complete(subtreeRoot, root, committedLanes);
+        continue;
+      } else {
+        // TODO (Offscreen) Also check: subtreeFlags & LayoutMask
+        var current = fiber.alternate;
+        var wasHidden = current !== null && current.memoizedState !== null;
+        var newOffscreenSubtreeWasHidden = wasHidden || offscreenSubtreeWasHidden;
+        var prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;
+        var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden; // Traverse the Offscreen subtree with the current Offscreen as the root.
+
+        offscreenSubtreeIsHidden = newOffscreenSubtreeIsHidden;
+        offscreenSubtreeWasHidden = newOffscreenSubtreeWasHidden;
+
+        if (offscreenSubtreeWasHidden && !prevOffscreenSubtreeWasHidden) {
+          // This is the root of a reappearing boundary. Turn its layout effects
+          // back on.
+          nextEffect = fiber;
+          reappearLayoutEffects_begin(fiber);
+        }
+
+        var child = firstChild;
+
+        while (child !== null) {
+          nextEffect = child;
+          commitLayoutEffects_begin(child, // New root; bubble back up to here and stop.
+          root, committedLanes);
+          child = child.sibling;
+        } // Restore Offscreen state and resume in our-progress traversal.
+
+
+        nextEffect = fiber;
+        offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+        commitLayoutMountEffects_complete(subtreeRoot, root, committedLanes);
+        continue;
+      }
+    }
+
     if ((fiber.subtreeFlags & LayoutMask) !== NoFlags && firstChild !== null) {
       firstChild.return = fiber;
       nextEffect = firstChild;
@@ -14352,6 +14519,157 @@ function commitLayoutMountEffects_complete(subtreeRoot, root, committedLanes) {
   }
 }
 
+function disappearLayoutEffects_begin(subtreeRoot) {
+  while (nextEffect !== null) {
+    var fiber = nextEffect;
+    var firstChild = fiber.child; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)
+
+    switch (fiber.tag) {
+      case FunctionComponent:
+      case ForwardRef:
+      case MemoComponent:
+      case SimpleMemoComponent:
+        {
+          if ( fiber.mode & ProfileMode) {
+            try {
+              startLayoutEffectTimer();
+              commitHookEffectListUnmount(Layout, fiber, fiber.return);
+            } finally {
+              recordLayoutEffectDuration(fiber);
+            }
+          } else {
+            commitHookEffectListUnmount(Layout, fiber, fiber.return);
+          }
+
+          break;
+        }
+
+      case ClassComponent:
+        {
+          // TODO (Offscreen) Check: flags & RefStatic
+          safelyDetachRef(fiber, fiber.return);
+          var instance = fiber.stateNode;
+
+          if (typeof instance.componentWillUnmount === 'function') {
+            safelyCallComponentWillUnmount(fiber, fiber.return, instance);
+          }
+
+          break;
+        }
+
+      case HostComponent:
+        {
+          safelyDetachRef(fiber, fiber.return);
+          break;
+        }
+
+      case OffscreenComponent:
+        {
+          // Check if this is a
+          var isHidden = fiber.memoizedState !== null;
+
+          if (isHidden) {
+            // Nested Offscreen tree is already hidden. Don't disappear
+            // its effects.
+            disappearLayoutEffects_complete(subtreeRoot);
+            continue;
+          }
+
+          break;
+        }
+    } // TODO (Offscreen) Check: subtreeFlags & LayoutStatic
+
+
+    if (firstChild !== null) {
+      firstChild.return = fiber;
+      nextEffect = firstChild;
+    } else {
+      disappearLayoutEffects_complete(subtreeRoot);
+    }
+  }
+}
+
+function disappearLayoutEffects_complete(subtreeRoot) {
+  while (nextEffect !== null) {
+    var fiber = nextEffect;
+
+    if (fiber === subtreeRoot) {
+      nextEffect = null;
+      return;
+    }
+
+    var sibling = fiber.sibling;
+
+    if (sibling !== null) {
+      sibling.return = fiber.return;
+      nextEffect = sibling;
+      return;
+    }
+
+    nextEffect = fiber.return;
+  }
+}
+
+function reappearLayoutEffects_begin(subtreeRoot) {
+  while (nextEffect !== null) {
+    var fiber = nextEffect;
+    var firstChild = fiber.child;
+
+    if (fiber.tag === OffscreenComponent) {
+      var isHidden = fiber.memoizedState !== null;
+
+      if (isHidden) {
+        // Nested Offscreen tree is still hidden. Don't re-appear its effects.
+        reappearLayoutEffects_complete(subtreeRoot);
+        continue;
+      }
+    } // TODO (Offscreen) Check: subtreeFlags & LayoutStatic
+
+
+    if (firstChild !== null) {
+      // This node may have been reused from a previous render, so we can't
+      // assume its return pointer is correct.
+      firstChild.return = fiber;
+      nextEffect = firstChild;
+    } else {
+      reappearLayoutEffects_complete(subtreeRoot);
+    }
+  }
+}
+
+function reappearLayoutEffects_complete(subtreeRoot) {
+  while (nextEffect !== null) {
+    var fiber = nextEffect; // TODO (Offscreen) Check: flags & LayoutStatic
+
+    setCurrentFiber(fiber);
+
+    try {
+      reappearLayoutEffectsOnFiber(fiber);
+    } catch (error) {
+      captureCommitPhaseError(fiber, fiber.return, error);
+    }
+
+    resetCurrentFiber();
+
+    if (fiber === subtreeRoot) {
+      nextEffect = null;
+      return;
+    }
+
+    var sibling = fiber.sibling;
+
+    if (sibling !== null) {
+      // This node may have been reused from a previous render, so we can't
+      // assume its return pointer is correct.
+      sibling.return = fiber.return;
+      nextEffect = sibling;
+      return;
+    }
+
+    nextEffect = fiber.return;
+  }
+}
+
 function commitPassiveMountEffects(root, finishedWork, committedLanes, committedTransitions) {
   nextEffect = finishedWork;
   commitPassiveMountEffects_begin(finishedWork, root, committedLanes, committedTransitions);
@@ -14848,8 +15166,6 @@ function requestRetryLane(fiber) {
 }
 
 function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
-  checkForNestedUpdates();
-
   {
     if (isRunningInsertionEffect) {
       error('useInsertionEffect must not schedule updates.');
@@ -16486,7 +16802,7 @@ function jnd(timeElapsed) {
   return timeElapsed < 120 ? 120 : timeElapsed < 480 ? 480 : timeElapsed < 1080 ? 1080 : timeElapsed < 1920 ? 1920 : timeElapsed < 3000 ? 3000 : timeElapsed < 4320 ? 4320 : ceil(timeElapsed / 1960) * 1960;
 }
 
-function checkForNestedUpdates() {
+function throwIfInfiniteUpdateLoopDetected() {
   if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
     nestedUpdateCount = 0;
     rootWithNestedUpdates = null;
@@ -17689,7 +18005,7 @@ identifierPrefix, onRecoverableError, transitionCallbacks) {
   return root;
 }
 
-var ReactVersion = '18.2.0';
+var ReactVersion = '18.3.0-next-522f47345-20220614';
 
 var didWarnAboutNestedUpdates;