react-native-tvos 0.76.6-0 → 0.77.0-0

package/ReactCommon/react/renderer/mounting/tests/StateReconciliationTest.cpp

@@ -24,20 +24,6 @@
 
 using namespace facebook::react;
 
-class StateReconciliationTestFeatureFlags
-    : public ReactNativeFeatureFlagsDefaults {
- public:
-  explicit StateReconciliationTestFeatureFlags(bool useStateAlignmentMechanism)
-      : useStateAlignmentMechanism_(useStateAlignmentMechanism) {}
-
-  bool useStateAlignmentMechanism() override {
-    return useStateAlignmentMechanism_;
-  }
-
- private:
-  bool useStateAlignmentMechanism_;
-};
-
 class DummyShadowTreeDelegate : public ShadowTreeDelegate {
  public:
   RootShadowNode::Unshared shadowTreeWillCommit(
@@ -48,7 +34,7 @@ class DummyShadowTreeDelegate : public ShadowTreeDelegate {
   };
 
   void shadowTreeDidFinishTransaction(
-      MountingCoordinator::Shared mountingCoordinator,
+      std::shared_ptr<const MountingCoordinator> mountingCoordinator,
       bool mountSynchronously) const override {};
 };
 
@@ -82,20 +68,10 @@ class StateReconciliationTest : public ::testing::TestWithParam<bool> {
  public:
   StateReconciliationTest() : builder_(simpleComponentBuilder()) {}
 
-  void SetUp() override {
-    ReactNativeFeatureFlags::dangerouslyReset();
-    ReactNativeFeatureFlags::override(
-        std::make_unique<StateReconciliationTestFeatureFlags>(GetParam()));
-  }
-
-  void TearDown() override {
-    ReactNativeFeatureFlags::dangerouslyReset();
-  }
-
   ComponentBuilder builder_;
 };
 
-TEST_P(StateReconciliationTest, testStateReconciliation) {
+TEST_F(StateReconciliationTest, testStateReconciliation) {
   // ==== SETUP ====
 
   /*
@@ -158,15 +134,10 @@ TEST_P(StateReconciliationTest, testStateReconciliation) {
   auto state2 = scrollViewComponentDescriptor.createState(
       scrollViewFamily, std::make_shared<const ScrollViewState>());
 
-  auto newTraits = ShadowNodeTraits();
-  newTraits.set(ShadowNodeTraits::Trait::ClonedByNativeStateUpdate);
-
   auto rootShadowNodeState2 = initialRootShadowNode->cloneTree(
-      scrollViewFamily,
-      [&](const ShadowNode& oldShadowNode) {
-        return oldShadowNode.clone({.state = state2, .traits = newTraits});
-      },
-      newTraits);
+      scrollViewFamily, [&](const ShadowNode& oldShadowNode) {
+        return oldShadowNode.clone({.state = state2});
+      });
 
   EXPECT_EQ(
       findDescendantNode(*initialRootShadowNode, scrollViewFamily)->getState(),
@@ -190,11 +161,9 @@ TEST_P(StateReconciliationTest, testStateReconciliation) {
       scrollViewFamily, std::make_shared<const ScrollViewState>());
 
   auto rootShadowNodeState3 = rootShadowNodeState2->cloneTree(
-      scrollViewFamily,
-      [&](const ShadowNode& oldShadowNode) {
-        return oldShadowNode.clone({.state = state3, .traits = newTraits});
-      },
-      newTraits);
+      scrollViewFamily, [&](const ShadowNode& oldShadowNode) {
+        return oldShadowNode.clone({.state = state3});
+      });
 
   EXPECT_EQ(
       findDescendantNode(*rootShadowNodeState3, scrollViewFamily)->getState(),
@@ -232,7 +201,7 @@ TEST_P(StateReconciliationTest, testStateReconciliation) {
       state3->getRevision());
 }
 
-TEST_P(StateReconciliationTest, testCloneslessStateReconciliationDoesntClone) {
+TEST_F(StateReconciliationTest, testCloneslessStateReconciliationDoesntClone) {
   // ==== SETUP ====
   /*
    <Root>
@@ -286,15 +255,10 @@ TEST_P(StateReconciliationTest, testCloneslessStateReconciliationDoesntClone) {
   auto state2 = scrollViewComponentDescriptor.createState(
       scrollViewFamily, std::make_shared<const ScrollViewState>());
 
-  auto newTraits = ShadowNodeTraits();
-  newTraits.set(ShadowNodeTraits::Trait::ClonedByNativeStateUpdate);
-
   auto rootShadowNode2 = rootShadowNode1->cloneTree(
-      scrollViewFamily,
-      [&](const ShadowNode& oldShadowNode) {
-        return oldShadowNode.clone({.state = state2, .traits = newTraits});
-      },
-      newTraits);
+      scrollViewFamily, [&](const ShadowNode& oldShadowNode) {
+        return oldShadowNode.clone({.state = state2});
+      });
 
   EXPECT_EQ(
       findDescendantNode(*rootShadowNode2, scrollViewFamily)->getState(),
@@ -324,11 +288,9 @@ TEST_P(StateReconciliationTest, testCloneslessStateReconciliationDoesntClone) {
       scrollViewFamily, std::make_shared<const ScrollViewState>());
 
   auto rootShadowNodeClonedFromStateUpdate = rootShadowNode2->cloneTree(
-      scrollViewFamily,
-      [&](const ShadowNode& oldShadowNode) {
-        return oldShadowNode.clone({.state = state3, .traits = newTraits});
-      },
-      newTraits);
+      scrollViewFamily, [&](const ShadowNode& oldShadowNode) {
+        return oldShadowNode.clone({.state = state3});
+      });
 
   // ==== State update ====
 
@@ -351,15 +313,9 @@ TEST_P(StateReconciliationTest, testCloneslessStateReconciliationDoesntClone) {
   auto scrollViewShadowNode = findDescendantNode(shadowTree, scrollViewFamily);
 
   EXPECT_EQ(scrollViewShadowNode->getState(), state3);
-
-  if (GetParam()) {
-    // Checking that newlyClonedShadowNode was not cloned unnecessarly by state
-    // progression. This fails with the old algorithm.
-    EXPECT_EQ(scrollViewShadowNode, newlyClonedShadowNode.get());
-  }
 }
 
-TEST_P(StateReconciliationTest, testStateReconciliationScrollViewChildUpdate) {
+TEST_F(StateReconciliationTest, testStateReconciliationScrollViewChildUpdate) {
   // ==== SETUP ====
   /*
    <Root>
@@ -431,15 +387,10 @@ TEST_P(StateReconciliationTest, testStateReconciliationScrollViewChildUpdate) {
   auto state2 = scrollViewComponentDescriptor.createState(
       scrollViewFamily, std::make_shared<const ScrollViewState>());
 
-  auto newTraits = ShadowNodeTraits();
-  newTraits.set(ShadowNodeTraits::Trait::ClonedByNativeStateUpdate);
-
   auto rootShadowNode2 = initialRootShadowNode->cloneTree(
-      scrollViewFamily,
-      [&](const ShadowNode& oldShadowNode) {
-        return oldShadowNode.clone({.state = state2, .traits = newTraits});
-      },
-      newTraits);
+      scrollViewFamily, [&](const ShadowNode& oldShadowNode) {
+        return oldShadowNode.clone({.state = state2});
+      });
 
   shadowTree.commit(
       [&](const RootShadowNode& /*oldRootShadowNode*/) {
@@ -464,7 +415,7 @@ TEST_P(StateReconciliationTest, testStateReconciliationScrollViewChildUpdate) {
       newlyClonedViewShadowNode.get());
 }
 
-TEST_P(StateReconciliationTest, testScrollViewWithChildrenDeletion) {
+TEST_F(StateReconciliationTest, testScrollViewWithChildrenDeletion) {
   // ==== SETUP ====
 
   /*
@@ -539,18 +490,13 @@ TEST_P(StateReconciliationTest, testScrollViewWithChildrenDeletion) {
 
   // ==== State update ====
 
-  auto newTraits = ShadowNodeTraits();
-  newTraits.set(ShadowNodeTraits::Trait::ClonedByNativeStateUpdate);
-
   auto newState = scrollViewComponentDescriptor.createState(
       childBFamily, std::make_shared<const ScrollViewState>());
 
   auto rootShadowNodeClonedFromStateUpdate = rootNode->cloneTree(
-      childBFamily,
-      [&newState, newTraits](const ShadowNode& oldShadowNode) {
-        return oldShadowNode.clone({.state = newState, .traits = newTraits});
-      },
-      newTraits);
+      childBFamily, [&newState](const ShadowNode& oldShadowNode) {
+        return oldShadowNode.clone({.state = newState});
+      });
 
   shadowTree.commit(
       [&rootShadowNodeClonedFromStateUpdate](
@@ -578,7 +524,7 @@ TEST_P(StateReconciliationTest, testScrollViewWithChildrenDeletion) {
       newState);
 }
 
-TEST_P(StateReconciliationTest, testScrollViewWithComplexChildrenReorder) {
+TEST_F(StateReconciliationTest, testScrollViewWithComplexChildrenReorder) {
   // ==== SETUP ====
 
   /*
@@ -660,18 +606,13 @@ TEST_P(StateReconciliationTest, testScrollViewWithComplexChildrenReorder) {
 
   // ==== State update ====
 
-  auto newTraits = ShadowNodeTraits();
-  newTraits.set(ShadowNodeTraits::Trait::ClonedByNativeStateUpdate);
-
   auto newState = scrollViewComponentDescriptor.createState(
       childAFamily, std::make_shared<const ScrollViewState>());
 
   auto rootShadowNodeClonedFromStateUpdate = rootNode->cloneTree(
-      childAFamily,
-      [&newState, newTraits](const ShadowNode& oldShadowNode) {
-        return oldShadowNode.clone({.state = newState, .traits = newTraits});
-      },
-      newTraits);
+      childAFamily, [&newState](const ShadowNode& oldShadowNode) {
+        return oldShadowNode.clone({.state = newState});
+      });
 
   shadowTree.commit(
       [&rootShadowNodeClonedFromStateUpdate](
@@ -697,7 +638,7 @@ TEST_P(StateReconciliationTest, testScrollViewWithComplexChildrenReorder) {
   EXPECT_EQ(findDescendantNode(shadowTree, childAFamily)->getState(), newState);
 }
 
-TEST_P(StateReconciliationTest, testScrollViewWithChildrenReorder) {
+TEST_F(StateReconciliationTest, testScrollViewWithChildrenReorder) {
   // ==== SETUP ====
 
   /*
@@ -766,18 +707,13 @@ TEST_P(StateReconciliationTest, testScrollViewWithChildrenReorder) {
 
   // ==== State update ====
 
-  auto newTraits = ShadowNodeTraits();
-  newTraits.set(ShadowNodeTraits::Trait::ClonedByNativeStateUpdate);
-
   auto newState = scrollViewComponentDescriptor.createState(
       childAFamily, std::make_shared<const ScrollViewState>());
 
   auto rootShadowNodeClonedFromStateUpdate = rootNode->cloneTree(
-      childAFamily,
-      [&newState, newTraits](const ShadowNode& oldShadowNode) {
-        return oldShadowNode.clone({.state = newState, .traits = newTraits});
-      },
-      newTraits);
+      childAFamily, [&newState](const ShadowNode& oldShadowNode) {
+        return oldShadowNode.clone({.state = newState});
+      });
 
   shadowTree.commit(
       [&rootShadowNodeClonedFromStateUpdate](
@@ -803,7 +739,7 @@ TEST_P(StateReconciliationTest, testScrollViewWithChildrenReorder) {
   EXPECT_EQ(findDescendantNode(shadowTree, childAFamily)->getState(), newState);
 }
 
-TEST_P(StateReconciliationTest, testScrollViewWithChildrenAddition) {
+TEST_F(StateReconciliationTest, testScrollViewWithChildrenAddition) {
   // ==== SETUP ====
 
   /*
@@ -856,18 +792,13 @@ TEST_P(StateReconciliationTest, testScrollViewWithChildrenAddition) {
 
   // ==== State update ====
 
-  auto newTraits = ShadowNodeTraits();
-  newTraits.set(ShadowNodeTraits::Trait::ClonedByNativeStateUpdate);
-
   auto newState = scrollViewComponentDescriptor.createState(
       scrollViewFamily, std::make_shared<const ScrollViewState>());
 
   auto rootShadowNodeClonedFromStateUpdate = rootNode->cloneTree(
-      scrollViewFamily,
-      [&newState, newTraits](const ShadowNode& oldShadowNode) {
-        return oldShadowNode.clone({.state = newState, .traits = newTraits});
-      },
-      newTraits);
+      scrollViewFamily, [&newState](const ShadowNode& oldShadowNode) {
+        return oldShadowNode.clone({.state = newState});
+      });
 
   // ==== Tree with new child ====
 
@@ -922,8 +853,3 @@ TEST_P(StateReconciliationTest, testScrollViewWithChildrenAddition) {
       findDescendantNode(shadowTree, childB->getFamily())->getState(),
       newState);
 }
-
-INSTANTIATE_TEST_SUITE_P(
-    StateReconciliationTestInstantiation,
-    StateReconciliationTest,
-    testing::Values(false, true));

package/ReactCommon/react/renderer/observers/events/EventPerformanceLogger.cpp

@@ -9,7 +9,6 @@
 
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/timing/primitives.h>
-#include <react/utils/CoreFeatures.h>
 #include <unordered_map>
 
 namespace facebook::react {
@@ -103,7 +102,8 @@ EventPerformanceLogger::EventPerformanceLogger(
 
 EventTag EventPerformanceLogger::onEventStart(
     std::string_view name,
-    SharedEventTarget target) {
+    SharedEventTarget target,
+    DOMHighResTimeStamp eventStartTimeStamp) {
   auto performanceEntryReporter = performanceEntryReporter_.lock();
   if (performanceEntryReporter == nullptr) {
     return EMPTY_EVENT_TAG;
@@ -119,7 +119,11 @@ EventTag EventPerformanceLogger::onEventStart(
 
   auto eventTag = createEventTag();
 
-  auto timeStamp = performanceEntryReporter->getCurrentTimeStamp();
+  // The event start timestamp may be provided by the caller in order to
+  // specify the platform specific event start time.
+  auto timeStamp = eventStartTimeStamp == DOM_HIGH_RES_TIME_STAMP_UNSET
+      ? performanceEntryReporter->getCurrentTimeStamp()
+      : eventStartTimeStamp;
   {
     std::lock_guard lock(eventsInFlightMutex_);
     eventsInFlight_.emplace(
@@ -169,7 +173,7 @@ void EventPerformanceLogger::onEventProcessingEnd(EventTag tag) {
 
     const auto& name = entry.name;
 
-    performanceEntryReporter->logEventEntry(
+    performanceEntryReporter->reportEvent(
         std::string(name),
         entry.startTime,
         timeStamp - entry.startTime,
@@ -205,7 +209,7 @@ void EventPerformanceLogger::dispatchPendingEventTimingEntries(
       entry.isWaitingForMount = true;
       ++it;
     } else {
-      performanceEntryReporter->logEventEntry(
+      performanceEntryReporter->reportEvent(
           std::string(entry.name),
           entry.startTime,
           performanceEntryReporter->getCurrentTimeStamp() - entry.startTime,
@@ -235,7 +239,7 @@ void EventPerformanceLogger::shadowTreeDidMount(
     const auto& entry = it->second;
     if (entry.isWaitingForMount &&
         isTargetInRootShadowNode(entry.target, rootShadowNode)) {
-      performanceEntryReporter->logEventEntry(
+      performanceEntryReporter->reportEvent(
           std::string(entry.name),
           entry.startTime,
           mountTime - entry.startTime,

package/ReactCommon/react/renderer/observers/events/EventPerformanceLogger.h

@@ -27,8 +27,11 @@ class EventPerformanceLogger : public EventLogger,
 
 #pragma mark - EventLogger
 
-  EventTag onEventStart(std::string_view name, SharedEventTarget target)
-      override;
+  EventTag onEventStart(
+      std::string_view name,
+      SharedEventTarget target,
+      DOMHighResTimeStamp eventStartTimeStamp =
+          DOM_HIGH_RES_TIME_STAMP_UNSET) override;
   void onEventProcessingStart(EventTag tag) override;
   void onEventProcessingEnd(EventTag tag) override;
 

package/ReactCommon/react/renderer/observers/intersection/IntersectionObserver.cpp

@@ -17,10 +17,12 @@ namespace facebook::react {
 IntersectionObserver::IntersectionObserver(
     IntersectionObserverObserverId intersectionObserverId,
     ShadowNode::Shared targetShadowNode,
-    std::vector<Float> thresholds)
+    std::vector<Float> thresholds,
+    std::optional<std::vector<Float>> rootThresholds)
     : intersectionObserverId_(intersectionObserverId),
       targetShadowNode_(std::move(targetShadowNode)),
-      thresholds_(std::move(thresholds)) {}
+      thresholds_(std::move(thresholds)),
+      rootThresholds_(std::move(rootThresholds)) {}
 
 static Rect getRootBoundingRect(
     const LayoutableShadowNode& layoutableRootShadowNode) {
@@ -85,6 +87,18 @@ static Rect computeIntersection(
   return Rect::intersect(rootBoundingRect, clippedTargetBoundingRect);
 }
 
+static Float getHighestThresholdCrossed(
+    Float intersectionRatio,
+    const std::vector<Float>& thresholds) {
+  Float highestThreshold = -1.0f;
+  for (auto threshold : thresholds) {
+    if (intersectionRatio >= threshold) {
+      highestThreshold = threshold;
+    }
+  }
+  return highestThreshold;
+}
+
 // Partially equivalent to
 // https://w3c.github.io/IntersectionObserver/#update-intersection-observations-algo
 std::optional<IntersectionObserverEntry>
@@ -124,8 +138,22 @@ IntersectionObserver::updateIntersectionObservation(
     return setNotIntersectingState(rootBoundingRect, targetBoundingRect, time);
   }
 
-  auto highestThresholdCrossed = getHighestThresholdCrossed(intersectionRatio);
-  if (highestThresholdCrossed == -1) {
+  auto highestThresholdCrossed =
+      getHighestThresholdCrossed(intersectionRatio, thresholds_);
+
+  auto highestRootThresholdCrossed = -1.0f;
+  if (rootThresholds_.has_value()) {
+    Float rootBoundingRectArea =
+        rootBoundingRect.size.width * rootBoundingRect.size.height;
+    Float rootThresholdIntersectionRatio = rootBoundingRectArea == 0
+        ? 0
+        : intersectionRectArea / rootBoundingRectArea;
+    highestRootThresholdCrossed = getHighestThresholdCrossed(
+        rootThresholdIntersectionRatio, rootThresholds_.value());
+  }
+
+  if (highestThresholdCrossed == -1.0f &&
+      highestRootThresholdCrossed == -1.0f) {
     return setNotIntersectingState(rootBoundingRect, targetBoundingRect, time);
   }
 
@@ -134,6 +162,7 @@ IntersectionObserver::updateIntersectionObservation(
       targetBoundingRect,
       intersectionRect,
       highestThresholdCrossed,
+      highestRootThresholdCrossed,
       time);
 }
 
@@ -143,25 +172,16 @@ IntersectionObserver::updateIntersectionObservationForSurfaceUnmount(
   return setNotIntersectingState(Rect{}, Rect{}, time);
 }
 
-Float IntersectionObserver::getHighestThresholdCrossed(
-    Float intersectionRatio) {
-  Float highestThreshold = -1;
-  for (auto threshold : thresholds_) {
-    if (intersectionRatio >= threshold) {
-      highestThreshold = threshold;
-    }
-  }
-  return highestThreshold;
-}
-
 std::optional<IntersectionObserverEntry>
 IntersectionObserver::setIntersectingState(
     const Rect& rootBoundingRect,
     const Rect& targetBoundingRect,
     const Rect& intersectionRect,
     Float threshold,
+    Float rootThreshold,
     double time) {
-  auto newState = IntersectionObserverState::Intersecting(threshold);
+  auto newState =
+      IntersectionObserverState::Intersecting(threshold, rootThreshold);
 
   if (state_ != newState) {
     state_ = newState;

package/ReactCommon/react/renderer/observers/intersection/IntersectionObserver.h

@@ -35,7 +35,8 @@ class IntersectionObserver {
   IntersectionObserver(
       IntersectionObserverObserverId intersectionObserverId,
       ShadowNode::Shared targetShadowNode,
-      std::vector<Float> thresholds);
+      std::vector<Float> thresholds,
+      std::optional<std::vector<Float>> rootThresholds = std::nullopt);
 
   // Partially equivalent to
   // https://w3c.github.io/IntersectionObserver/#update-intersection-observations-algo
@@ -59,13 +60,12 @@ class IntersectionObserver {
   }
 
  private:
-  Float getHighestThresholdCrossed(Float intersectionRatio);
-
   std::optional<IntersectionObserverEntry> setIntersectingState(
       const Rect& rootBoundingRect,
       const Rect& targetBoundingRect,
       const Rect& intersectionRect,
       Float threshold,
+      Float rootThreshold,
       double time);
 
   std::optional<IntersectionObserverEntry> setNotIntersectingState(
@@ -76,6 +76,7 @@ class IntersectionObserver {
   IntersectionObserverObserverId intersectionObserverId_;
   ShadowNode::Shared targetShadowNode_;
   std::vector<Float> thresholds_;
+  std::optional<std::vector<Float>> rootThresholds_;
   mutable IntersectionObserverState state_ =
       IntersectionObserverState::Initial();
 };

package/ReactCommon/react/renderer/observers/intersection/IntersectionObserverManager.cpp

@@ -19,6 +19,7 @@ void IntersectionObserverManager::observe(
     IntersectionObserverObserverId intersectionObserverId,
     const ShadowNode::Shared& shadowNode,
     std::vector<Float> thresholds,
+    std::optional<std::vector<Float>> rootThresholds,
     const UIManager& uiManager) {
   SystraceSection s("IntersectionObserverManager::observe");
 
@@ -34,7 +35,10 @@ void IntersectionObserverManager::observe(
 
     auto& observers = observersBySurfaceId_[surfaceId];
     observers.emplace_back(IntersectionObserver{
-        intersectionObserverId, shadowNode, std::move(thresholds)});
+        intersectionObserverId,
+        shadowNode,
+        std::move(thresholds),
+        std::move(rootThresholds)});
     observer = &observers.back();
   }
 
@@ -43,7 +47,7 @@ void IntersectionObserverManager::observe(
   // (like on the Web) and we'd send the initial notification there, but as
   // we don't have it we have to run this check once and manually dispatch.
   auto& shadowTreeRegistry = uiManager.getShadowTreeRegistry();
-  MountingCoordinator::Shared mountingCoordinator = nullptr;
+  std::shared_ptr<const MountingCoordinator> mountingCoordinator = nullptr;
   RootShadowNode::Shared rootShadowNode = nullptr;
   shadowTreeRegistry.visit(surfaceId, [&](const ShadowTree& shadowTree) {
     mountingCoordinator = shadowTree.getMountingCoordinator();

package/ReactCommon/react/renderer/observers/intersection/IntersectionObserverManager.h

@@ -24,6 +24,7 @@ class IntersectionObserverManager final : public UIManagerMountHook {
       IntersectionObserverObserverId intersectionObserverId,
       const ShadowNode::Shared& shadowNode,
       std::vector<Float> thresholds,
+      std::optional<std::vector<Float>> rootThresholds,
       const UIManager& uiManager);
 
   void unobserve(

package/ReactCommon/react/renderer/observers/intersection/IntersectionObserverState.cpp

@@ -22,9 +22,10 @@ IntersectionObserverState IntersectionObserverState::NotIntersecting() {
 }
 
 IntersectionObserverState IntersectionObserverState::Intersecting(
-    Float threshold) {
-  return IntersectionObserverState(
-      IntersectionObserverStateType::Intersecting, threshold);
+    Float threshold,
+    Float rootThreshold) {
+  return {
+      IntersectionObserverStateType::Intersecting, threshold, rootThreshold};
 }
 
 IntersectionObserverState::IntersectionObserverState(
@@ -33,8 +34,9 @@ IntersectionObserverState::IntersectionObserverState(
 
 IntersectionObserverState::IntersectionObserverState(
     IntersectionObserverStateType state,
-    Float threshold)
-    : state_(state), threshold_(threshold) {}
+    Float threshold,
+    Float rootThreshold)
+    : state_(state), threshold_(threshold), rootThreshold_(rootThreshold) {}
 
 bool IntersectionObserverState::isIntersecting() const {
   return state_ == IntersectionObserverStateType::Intersecting;
@@ -50,7 +52,8 @@ bool IntersectionObserverState::operator==(
     return true;
   }
 
-  return threshold_ == other.threshold_;
+  return threshold_ == other.threshold_ &&
+      rootThreshold_ == other.rootThreshold_;
 }
 
 bool IntersectionObserverState::operator!=(

package/ReactCommon/react/renderer/observers/intersection/IntersectionObserverState.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <react/renderer/graphics/Float.h>
+#include <optional>
 
 namespace {
 enum class IntersectionObserverStateType {
@@ -24,6 +25,9 @@ class IntersectionObserverState {
   static IntersectionObserverState Initial();
   static IntersectionObserverState NotIntersecting();
   static IntersectionObserverState Intersecting(Float threshold);
+  static IntersectionObserverState Intersecting(
+      Float threshold,
+      Float rootThreshold);
 
   bool isIntersecting() const;
 
@@ -32,15 +36,21 @@ class IntersectionObserverState {
 
  private:
   explicit IntersectionObserverState(IntersectionObserverStateType state);
+
   IntersectionObserverState(
       IntersectionObserverStateType state,
-      Float threshold);
+      Float threshold,
+      Float rootThreshold);
 
   IntersectionObserverStateType state_;
 
   // This value is only relevant if the state is
   // IntersectionObserverStateType::Intersecting.
   Float threshold_{};
+
+  // This value is only relevant if the state is
+  // IntersectionObserverStateType::Intersecting.
+  std::optional<Float> rootThreshold_{};
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/observers/mutation/MutationObserver.cpp

@@ -133,31 +133,30 @@ void MutationObserver::recordMutationsInTarget(
   }
 
   recordMutationsInSubtrees(
-      std::move(targetShadowNode),
-      *oldTargetShadowNode,
-      *newTargetShadowNode,
+      oldTargetShadowNode,
+      newTargetShadowNode,
       observeSubtree,
       recordedMutations,
       processedNodes);
 }
 
 void MutationObserver::recordMutationsInSubtrees(
-    ShadowNode::Shared targetShadowNode,
-    const ShadowNode& oldNode,
-    const ShadowNode& newNode,
+    const ShadowNode::Shared& oldNode,
+    const ShadowNode::Shared& newNode,
     bool observeSubtree,
     std::vector<MutationRecord>& recordedMutations,
-    SetOfShadowNodePointers processedNodes) const {
-  bool isSameNode = &oldNode == &newNode;
+    SetOfShadowNodePointers& processedNodes) const {
+  bool isSameNode = oldNode.get() == newNode.get();
   // If the nodes are referentially equal, their children are also the same.
-  if (isSameNode || processedNodes.find(&newNode) != processedNodes.end()) {
+  if (isSameNode ||
+      processedNodes.find(oldNode.get()) != processedNodes.end()) {
     return;
   }
 
-  processedNodes.insert(&newNode);
+  processedNodes.insert(oldNode.get());
 
-  auto oldChildren = oldNode.getChildren();
-  auto newChildren = newNode.getChildren();
+  auto oldChildren = oldNode->getChildren();
+  auto newChildren = newNode->getChildren();
 
   std::vector<ShadowNode::Shared> addedNodes;
   std::vector<ShadowNode::Shared> removedNodes;
@@ -171,9 +170,8 @@ void MutationObserver::recordMutationsInSubtrees(
       // Nodes are present in both tress. If `subtree` is set to true,
       // we continue checking their children.
       recordMutationsInSubtrees(
-          targetShadowNode,
-          *oldChild,
-          *newChild,
+          oldChild,
+          newChild,
           observeSubtree,
           recordedMutations,
           processedNodes);
@@ -191,7 +189,7 @@ void MutationObserver::recordMutationsInSubtrees(
   if (!addedNodes.empty() || !removedNodes.empty()) {
     recordedMutations.emplace_back(MutationRecord{
         mutationObserverId_,
-        targetShadowNode,
+        oldNode,
         std::move(addedNodes),
         std::move(removedNodes)});
   }