react-native-tvos 0.87.1-0 → 0.88.0-0rc2

package/ReactCommon/react/renderer/observers/resize/tests/ResizeObserverTest.cpp

@@ -0,0 +1,382 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <gtest/gtest.h>
+#include <react/renderer/components/view/ViewShadowNode.h>
+#include <react/renderer/element/Element.h>
+#include <react/renderer/element/testUtils.h>
+#include <react/renderer/observers/resize/ResizeObserver.h>
+
+namespace facebook::react {
+
+namespace {
+
+constexpr ResizeObserverObserverId kObserverId{1};
+constexpr uint64_t kObservationSequence{0};
+
+LayoutMetrics layoutMetricsWithFrameSize(Float width, Float height) {
+  auto layoutMetrics = EmptyLayoutMetrics;
+  layoutMetrics.frame.origin = {.x = 0, .y = 0};
+  layoutMetrics.frame.size = {.width = width, .height = height};
+  return layoutMetrics;
+}
+
+} // namespace
+
+/*
+ * ┌─────────────────────┐
+ * │<Root>               │
+ * │  ┌────────────────┐ │
+ * │  │<View> container│ │
+ * │  │  ┌───────────┐ │ │
+ * │  │  │<View>     │ │ │
+ * │  │  │  target   │ │ │
+ * │  │  └───────────┘ │ │
+ * │  └────────────────┘ │
+ * └─────────────────────┘
+ */
+class ResizeObserverTest : public ::testing::Test {
+ protected:
+  ComponentBuilder builder_;
+  std::shared_ptr<RootShadowNode> rootShadowNode_;
+  std::shared_ptr<ViewShadowNode> containerShadowNode_;
+  std::shared_ptr<ViewShadowNode> targetShadowNode_;
+
+  ResizeObserverTest() : builder_(simpleComponentBuilder()) {}
+
+  void buildTree(
+      const LayoutMetrics& targetLayoutMetrics,
+      const LayoutMetrics& containerLayoutMetrics =
+          layoutMetricsWithFrameSize(1000, 1000)) {
+    // clang-format off
+    auto element =
+        Element<RootShadowNode>()
+          .reference(rootShadowNode_)
+          .tag(1)
+          .children({
+            Element<ViewShadowNode>()
+              .tag(2)
+              .reference(containerShadowNode_)
+              .finalize([&](ViewShadowNode &shadowNode){
+                shadowNode.setLayoutMetrics(containerLayoutMetrics);
+              })
+              .children({
+                Element<ViewShadowNode>()
+                  .tag(3)
+                  .reference(targetShadowNode_)
+                  .finalize([&](ViewShadowNode &shadowNode){
+                    shadowNode.setLayoutMetrics(targetLayoutMetrics);
+                  })
+              })
+          });
+    // clang-format on
+
+    builder_.build(element);
+  }
+
+  ResizeObserver makeObserver(
+      ResizeObserverBoxOptions boxOptions =
+          ResizeObserverBoxOptions::ContentBox) {
+    return ResizeObserver{
+        kObserverId,
+        targetShadowNode_->getFamilyShared(),
+        boxOptions,
+        kObservationSequence};
+  }
+
+  // Returns a revision of the tree in which the target has been removed from
+  // its parent, so `getAncestors` no longer resolves it.
+  std::shared_ptr<ShadowNode> treeWithoutTarget() {
+    return rootShadowNode_->cloneTree(
+        containerShadowNode_->getFamily(), [](const ShadowNode& oldShadowNode) {
+          return oldShadowNode.clone(
+              {.props = ShadowNodeFragment::propsPlaceholder(),
+               .children = ShadowNode::emptySharedShadowNodeSharedList()});
+        });
+  }
+
+  // Returns a revision of the tree in which the target carries new layout
+  // metrics.
+  std::shared_ptr<ShadowNode> treeWithTargetLayoutMetrics(
+      const LayoutMetrics& layoutMetrics) {
+    return rootShadowNode_->cloneTree(
+        targetShadowNode_->getFamily(), [&](const ShadowNode& oldShadowNode) {
+          auto clone = oldShadowNode.clone(
+              {.props = ShadowNodeFragment::propsPlaceholder()});
+          static_cast<ViewShadowNode&>(*clone).setLayoutMetrics(layoutMetrics);
+          return clone;
+        });
+  }
+
+  static const RootShadowNode& asRoot(const std::shared_ptr<ShadowNode>& node) {
+    return static_cast<const RootShadowNode&>(*node);
+  }
+};
+
+#pragma mark - Box selection
+
+TEST_F(ResizeObserverTest, initialDeliveryReportsContentBox) {
+  buildTree(layoutMetricsWithFrameSize(100, 200));
+
+  auto observer = makeObserver();
+  auto result = observer.computeActiveObservation(*rootShadowNode_);
+
+  ASSERT_TRUE(result.entry.has_value());
+  EXPECT_EQ(result.observedSize.width, 100);
+  EXPECT_EQ(result.observedSize.height, 200);
+  EXPECT_EQ(result.entry->contentBoxSize.width, 100);
+  EXPECT_EQ(result.entry->borderBoxSize.width, 100);
+  EXPECT_FALSE(result.detached);
+}
+
+TEST_F(ResizeObserverTest, contentBoxSubtractsContentInsets) {
+  auto layoutMetrics = layoutMetricsWithFrameSize(100, 200);
+  layoutMetrics.contentInsets =
+      EdgeInsets{.left = 10, .top = 20, .right = 10, .bottom = 20};
+  buildTree(layoutMetrics);
+
+  auto observer = makeObserver(ResizeObserverBoxOptions::ContentBox);
+  auto result = observer.computeActiveObservation(*rootShadowNode_);
+
+  ASSERT_TRUE(result.entry.has_value());
+  EXPECT_EQ(result.entry->contentBoxSize.width, 80);
+  EXPECT_EQ(result.entry->contentBoxSize.height, 160);
+  // The border box is always the full frame, regardless of insets.
+  EXPECT_EQ(result.entry->borderBoxSize.width, 100);
+  EXPECT_EQ(result.entry->borderBoxSize.height, 200);
+  EXPECT_EQ(result.observedSize.width, 80);
+}
+
+TEST_F(ResizeObserverTest, borderBoxOptionObservesFrameSize) {
+  auto layoutMetrics = layoutMetricsWithFrameSize(100, 200);
+  layoutMetrics.contentInsets =
+      EdgeInsets{.left = 10, .top = 20, .right = 10, .bottom = 20};
+  buildTree(layoutMetrics);
+
+  auto observer = makeObserver(ResizeObserverBoxOptions::BorderBox);
+  auto result = observer.computeActiveObservation(*rootShadowNode_);
+
+  ASSERT_TRUE(result.entry.has_value());
+  EXPECT_EQ(result.observedSize.width, 100);
+  EXPECT_EQ(result.observedSize.height, 200);
+}
+
+TEST_F(ResizeObserverTest, devicePixelContentBoxScalesAndRounds) {
+  auto layoutMetrics = layoutMetricsWithFrameSize(10.4f, 20.6f);
+  layoutMetrics.pointScaleFactor = 3;
+  buildTree(layoutMetrics);
+
+  auto observer = makeObserver(ResizeObserverBoxOptions::DevicePixelContentBox);
+  auto result = observer.computeActiveObservation(*rootShadowNode_);
+
+  ASSERT_TRUE(result.entry.has_value());
+  // round(10.4 * 3) == 31, round(20.6 * 3) == 62
+  EXPECT_EQ(result.entry->devicePixelContentBoxSize.width, 31);
+  EXPECT_EQ(result.entry->devicePixelContentBoxSize.height, 62);
+  EXPECT_EQ(result.observedSize.width, 31);
+}
+
+TEST_F(ResizeObserverTest, contentBoxIsClampedToZeroWhenInsetsExceedFrame) {
+  auto layoutMetrics = layoutMetricsWithFrameSize(10, 10);
+  layoutMetrics.contentInsets =
+      EdgeInsets{.left = 20, .top = 20, .right = 20, .bottom = 20};
+  buildTree(layoutMetrics);
+
+  auto observer = makeObserver();
+  auto result = observer.computeActiveObservation(*rootShadowNode_);
+
+  ASSERT_TRUE(result.entry.has_value());
+  EXPECT_EQ(result.entry->contentBoxSize.width, 0);
+  EXPECT_EQ(result.entry->contentBoxSize.height, 0);
+}
+
+TEST_F(ResizeObserverTest, contentRectOriginExcludesBorders) {
+  auto layoutMetrics = layoutMetricsWithFrameSize(100, 200);
+  layoutMetrics.contentInsets =
+      EdgeInsets{.left = 10, .top = 20, .right = 10, .bottom = 20};
+  layoutMetrics.borderWidth =
+      EdgeInsets{.left = 4, .top = 6, .right = 4, .bottom = 6};
+  buildTree(layoutMetrics);
+
+  auto observer = makeObserver();
+  auto result = observer.computeActiveObservation(*rootShadowNode_);
+
+  ASSERT_TRUE(result.entry.has_value());
+  // Per spec, contentRect's origin is the padding only (insets minus borders).
+  EXPECT_EQ(result.entry->contentRect.origin.x, 6);
+  EXPECT_EQ(result.entry->contentRect.origin.y, 14);
+}
+
+#pragma mark - Depth
+
+TEST_F(ResizeObserverTest, targetDepthCountsPathToRootInclusive) {
+  buildTree(layoutMetricsWithFrameSize(100, 200));
+
+  auto observer = makeObserver();
+  auto result = observer.computeActiveObservation(*rootShadowNode_);
+
+  // root -> container -> target
+  EXPECT_EQ(result.targetDepth, 3u);
+}
+
+#pragma mark - Change detection
+
+TEST_F(ResizeObserverTest, unchangedSizeProducesNoEntryAfterReport) {
+  buildTree(layoutMetricsWithFrameSize(100, 200));
+
+  auto observer = makeObserver();
+  auto initial = observer.computeActiveObservation(*rootShadowNode_);
+  ASSERT_TRUE(initial.entry.has_value());
+  observer.markAsReported(initial);
+
+  auto second = observer.computeActiveObservation(*rootShadowNode_);
+  EXPECT_FALSE(second.entry.has_value());
+}
+
+TEST_F(ResizeObserverTest, changedSizeProducesEntryAfterReport) {
+  buildTree(layoutMetricsWithFrameSize(100, 200));
+
+  auto observer = makeObserver();
+  auto initial = observer.computeActiveObservation(*rootShadowNode_);
+  ASSERT_TRUE(initial.entry.has_value());
+  observer.markAsReported(initial);
+
+  auto resized =
+      treeWithTargetLayoutMetrics(layoutMetricsWithFrameSize(100, 300));
+  auto second = observer.computeActiveObservation(asRoot(resized));
+
+  ASSERT_TRUE(second.entry.has_value());
+  EXPECT_EQ(second.observedSize.height, 300);
+}
+
+TEST_F(ResizeObserverTest, initialDeliveryHappensEvenForZeroSizedTarget) {
+  buildTree(layoutMetricsWithFrameSize(0, 0));
+
+  auto observer = makeObserver();
+  EXPECT_TRUE(observer.needsInitialDeliveryCheck());
+
+  auto result = observer.computeActiveObservation(*rootShadowNode_);
+
+  // A 0x0 target still gets its first delivery, matching browsers.
+  ASSERT_TRUE(result.entry.has_value());
+  EXPECT_EQ(result.observedSize.width, 0);
+
+  observer.markAsReported(result);
+  EXPECT_FALSE(observer.needsInitialDeliveryCheck());
+}
+
+#pragma mark - Hidden targets
+
+TEST_F(ResizeObserverTest, displayNoneTargetReportsZeroSize) {
+  auto layoutMetrics = layoutMetricsWithFrameSize(100, 200);
+  layoutMetrics.displayType = DisplayType::None;
+  buildTree(layoutMetrics);
+
+  auto observer = makeObserver();
+  auto result = observer.computeActiveObservation(*rootShadowNode_);
+
+  ASSERT_TRUE(result.entry.has_value());
+  EXPECT_EQ(result.observedSize.width, 0);
+  EXPECT_EQ(result.observedSize.height, 0);
+  EXPECT_EQ(result.entry->borderBoxSize.width, 0);
+}
+
+TEST_F(ResizeObserverTest, hiddenAncestorReportsZeroSize) {
+  auto containerLayoutMetrics = layoutMetricsWithFrameSize(1000, 1000);
+  containerLayoutMetrics.displayType = DisplayType::None;
+  buildTree(layoutMetricsWithFrameSize(100, 200), containerLayoutMetrics);
+
+  auto observer = makeObserver();
+  auto result = observer.computeActiveObservation(*rootShadowNode_);
+
+  // Descendants of a `display: none` node are not laid out, so their own
+  // metrics are not a reportable size.
+  ASSERT_TRUE(result.entry.has_value());
+  EXPECT_EQ(result.observedSize.width, 0);
+  EXPECT_EQ(result.observedSize.height, 0);
+}
+
+#pragma mark - Detachment
+
+TEST_F(ResizeObserverTest, detachedTargetDeliversFinalZeroEntryOnce) {
+  buildTree(layoutMetricsWithFrameSize(100, 200));
+
+  auto observer = makeObserver();
+  auto initial = observer.computeActiveObservation(*rootShadowNode_);
+  ASSERT_TRUE(initial.entry.has_value());
+  observer.markAsReported(initial);
+
+  auto detachedTree = treeWithoutTarget();
+  auto final = observer.computeActiveObservation(asRoot(detachedTree));
+
+  ASSERT_TRUE(final.entry.has_value());
+  EXPECT_TRUE(final.detached);
+  EXPECT_EQ(final.observedSize.width, 0);
+  EXPECT_EQ(final.observedSize.height, 0);
+
+  observer.markAsReported(final);
+  EXPECT_TRUE(observer.hasDeliveredDetachedState());
+
+  // The final 0x0 is delivered exactly once.
+  auto afterFinal = observer.computeActiveObservation(asRoot(detachedTree));
+  EXPECT_FALSE(afterFinal.entry.has_value());
+}
+
+// Regression test: a target that was already reporting 0x0 when it left the
+// tree produces no final entry, because 0x0 was already delivered. Before the
+// fix nothing recorded the detachment in that case, so
+// `hasDeliveredDetachedState()` stayed false and
+// `ResizeObserverManager::gatherActiveResizeObservations` recomputed this
+// observation - walking the tree via `getAncestors` - on every subsequent
+// commit to the surface, forever.
+TEST_F(ResizeObserverTest, detachedStateIsRecordedWhenFinalEntryIsSuppressed) {
+  auto hiddenLayoutMetrics = layoutMetricsWithFrameSize(100, 200);
+  hiddenLayoutMetrics.displayType = DisplayType::None;
+  buildTree(hiddenLayoutMetrics);
+
+  auto observer = makeObserver();
+  auto initial = observer.computeActiveObservation(*rootShadowNode_);
+  ASSERT_TRUE(initial.entry.has_value());
+  ASSERT_EQ(initial.observedSize.width, 0);
+  observer.markAsReported(initial);
+  ASSERT_FALSE(observer.hasDeliveredDetachedState());
+
+  auto detachedTree = treeWithoutTarget();
+  auto detachedResult = observer.computeActiveObservation(asRoot(detachedTree));
+
+  // Suppressed: the observed box is still 0x0, so there is nothing to deliver.
+  EXPECT_FALSE(detachedResult.entry.has_value());
+  EXPECT_TRUE(detachedResult.detached);
+
+  observer.updateDetachedState(detachedResult.detached);
+  EXPECT_TRUE(observer.hasDeliveredDetachedState());
+}
+
+TEST_F(ResizeObserverTest, detachedStateIsClearedWhenTargetIsReattached) {
+  buildTree(layoutMetricsWithFrameSize(100, 200));
+
+  auto observer = makeObserver();
+  auto initial = observer.computeActiveObservation(*rootShadowNode_);
+  ASSERT_TRUE(initial.entry.has_value());
+  observer.markAsReported(initial);
+
+  auto detachedTree = treeWithoutTarget();
+  auto final = observer.computeActiveObservation(asRoot(detachedTree));
+  ASSERT_TRUE(final.entry.has_value());
+  observer.markAsReported(final);
+  ASSERT_TRUE(observer.hasDeliveredDetachedState());
+
+  // The original tree still contains the target; observing it again must
+  // resume normal delivery.
+  auto reattached = observer.computeActiveObservation(*rootShadowNode_);
+  ASSERT_TRUE(reattached.entry.has_value());
+  EXPECT_FALSE(reattached.detached);
+  observer.markAsReported(reattached);
+  EXPECT_FALSE(observer.hasDeliveredDetachedState());
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/runtimescheduler/CMakeLists.txt

@@ -17,6 +17,7 @@ target_link_libraries(react_renderer_runtimescheduler
         callinvoker
         jserrorhandler
         jsi
+        react_cxxstableapi
         react_debug
         react_performance_timeline
         react_renderer_consistency

package/ReactCommon/react/renderer/runtimescheduler/React-runtimescheduler.podspec

@@ -43,6 +43,7 @@ Pod::Spec.new do |s|
   add_dependency(s, "React-runtimeexecutor", :additional_framework_paths => ["platform/ios"])
   s.dependency "React-callinvoker"
   s.dependency "React-cxxreact"
+  s.dependency "React-cxxstableapi"
   s.dependency "React-rendererdebug"
   s.dependency "React-utils"
   s.dependency "React-featureflags"
@@ -57,4 +58,6 @@ Pod::Spec.new do |s|
   depend_on_js_engine(s)
   add_rn_third_party_dependencies(s)
   add_rncore_dependency(s)
+
+  mark_as_react_native_build(s)
 end

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler.cpp

@@ -153,4 +153,10 @@ void RuntimeScheduler::setIntersectionObserverDelegate(
       intersectionObserverDelegate);
 }
 
+void RuntimeScheduler::setResizeObserverDelegate(
+    RuntimeSchedulerResizeObserverDelegate* resizeObserverDelegate) {
+  return runtimeSchedulerImpl_->setResizeObserverDelegate(
+      resizeObserverDelegate);
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <ReactCommon/RuntimeExecutor.h>
 #include <jsi/hermes-interfaces.h>
 #include <react/performance/timeline/PerformanceEntryReporter.h>
@@ -16,6 +18,7 @@
 #include <react/timing/primitives.h>
 #include "RuntimeSchedulerEventTimingDelegate.h"
 #include "RuntimeSchedulerIntersectionObserverDelegate.h"
+#include "RuntimeSchedulerResizeObserverDelegate.h"
 
 namespace facebook::react {
 
@@ -55,6 +58,7 @@ class RuntimeSchedulerBase : public facebook::hermes::IEventLoopControl {
   virtual void setEventTimingDelegate(RuntimeSchedulerEventTimingDelegate *eventTimingDelegate) = 0;
   virtual void setIntersectionObserverDelegate(
       RuntimeSchedulerIntersectionObserverDelegate *intersectionObserverDelegate) = 0;
+  virtual void setResizeObserverDelegate(RuntimeSchedulerResizeObserverDelegate *resizeObserverDelegate) = 0;
 };
 
 // This is a proxy for RuntimeScheduler implementation, which will be selected
@@ -167,6 +171,8 @@ class RuntimeScheduler final : public RuntimeSchedulerBase {
   void setIntersectionObserverDelegate(
       RuntimeSchedulerIntersectionObserverDelegate *intersectionObserverDelegate) override;
 
+  void setResizeObserverDelegate(RuntimeSchedulerResizeObserverDelegate *resizeObserverDelegate) override;
+
  private:
   // Actual implementation, stored as a unique pointer to simplify memory
   // management.

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerBinding.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <jsi/jsi.h>
 
 namespace facebook::react {

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerCallInvoker.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <ReactCommon/CallInvoker.h>
 #include <memory>
 
@@ -17,7 +19,9 @@ class RuntimeScheduler;
  * Exposes RuntimeScheduler to native modules. All calls invoked on JavaScript
  * queue from native modules will be funneled through RuntimeScheduler.
  */
-class RuntimeSchedulerCallInvoker : public CallInvoker {
+class [[deprecated(
+    "Use ReactInstance::createJSCallInvoker(), which shares the instance's buffered runtime executor so async calls are ordered against callable module calls")]]
+RuntimeSchedulerCallInvoker : public CallInvoker {
  public:
   RuntimeSchedulerCallInvoker(std::weak_ptr<RuntimeScheduler> runtimeScheduler);
 

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerEventTimingDelegate.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <react/timing/primitives.h>
 #include <unordered_set>
 

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerIntersectionObserverDelegate.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <unordered_set>
 
 namespace facebook::react {

package/ReactCommon/react/renderer/runtimescheduler/RuntimeSchedulerResizeObserverDelegate.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/cxxstableapi/FrameworksGuard.h>
+
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+class RuntimeSchedulerResizeObserverDelegate {
+ public:
+  virtual ~RuntimeSchedulerResizeObserverDelegate() = default;
+
+  virtual void runResizeObservations(jsi::Runtime &runtime) = 0;
+};
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Legacy.cpp

@@ -222,6 +222,11 @@ void RuntimeScheduler_Legacy::setIntersectionObserverDelegate(
   // No-op in the legacy scheduler
 }
 
+void RuntimeScheduler_Legacy::setResizeObserverDelegate(
+    RuntimeSchedulerResizeObserverDelegate* /*resizeObserverDelegate*/) {
+  // No-op in the legacy scheduler
+}
+
 #pragma mark - Private
 
 void RuntimeScheduler_Legacy::scheduleWorkLoopIfNecessary() {

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Legacy.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #ifndef RCT_REMOVE_LEGACY_ARCH
 
 #include <ReactCommon/RuntimeExecutor.h>
@@ -133,6 +135,8 @@ class RuntimeScheduler_Legacy final : public RuntimeSchedulerBase {
   void setIntersectionObserverDelegate(
       RuntimeSchedulerIntersectionObserverDelegate *intersectionObserverDelegate) override;
 
+  void setResizeObserverDelegate(RuntimeSchedulerResizeObserverDelegate *resizeObserverDelegate) override;
+
  private:
   std::priority_queue<std::shared_ptr<Task>, std::vector<std::shared_ptr<Task>>, TaskPriorityComparer> taskQueue_;
 

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Modern.cpp

@@ -10,7 +10,6 @@
 #include <ReactCommon/RuntimeExecutorSyncUIThreadUtils.h>
 #include <cxxreact/TraceSection.h>
 #include <jsinspector-modern/tracing/EventLoopReporter.h>
-#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/consistency/ScopedShadowTreeRevisionLock.h>
 #include <react/timing/primitives.h>
 #include <react/utils/OnScopeExit.h>
@@ -232,6 +231,11 @@ void RuntimeScheduler_Modern::setIntersectionObserverDelegate(
   intersectionObserverDelegate_ = intersectionObserverDelegate;
 }
 
+void RuntimeScheduler_Modern::setResizeObserverDelegate(
+    RuntimeSchedulerResizeObserverDelegate* resizeObserverDelegate) {
+  resizeObserverDelegate_ = resizeObserverDelegate;
+}
+
 #pragma mark - Private
 
 void RuntimeScheduler_Modern::scheduleTask(std::shared_ptr<Task> task) {
@@ -336,7 +340,7 @@ void RuntimeScheduler_Modern::runEventLoopTick(
   reportLongTasks(task, taskStartTime, taskEndTime);
 
   // "Update the rendering" step.
-  updateRendering(taskEndTime);
+  updateRendering(runtime, taskEndTime);
 
   currentTask_ = nullptr;
 }
@@ -346,7 +350,9 @@ void RuntimeScheduler_Modern::runEventLoopTick(
  * event loop. See
  * https://html.spec.whatwg.org/multipage/webappapis.html#update-the-rendering.
  */
-void RuntimeScheduler_Modern::updateRendering(HighResTimeStamp taskEndTime) {
+void RuntimeScheduler_Modern::updateRendering(
+    jsi::Runtime& runtime,
+    HighResTimeStamp taskEndTime) {
   TraceSection s("RuntimeScheduler::updateRendering");
 
   // This is the integration of the Event Timing API in the Event Loop.
@@ -357,6 +363,28 @@ void RuntimeScheduler_Modern::updateRendering(HighResTimeStamp taskEndTime) {
         taskEndTime, surfaceIdsWithPendingRenderingUpdates_);
   }
 
+  // This is the integration of the Resize Observer API in the Event Loop. See
+  // https://w3c.github.io/csswg-drafts/resize-observer/#broadcast-resize-notifications-h
+  // The delegate runs the spec's depth-bounded gather/broadcast loop
+  // internally; this call site stays a single invocation per tick.
+  if (resizeObserverDelegate_ != nullptr) {
+    // This delivers the observations to JS synchronously, so it is outside the
+    // error boundary of `executeTask`. Report the error without going through
+    // `handleTaskError`: we are already inside the "update the rendering" step,
+    // so clearing the queues here would drop the pending rendering updates this
+    // step is about to drain, and a throwing observer callback would abort the
+    // remaining steps below.
+    try {
+      resizeObserverDelegate_->runResizeObservations(runtime);
+    } catch (jsi::JSError& error) {
+      onTaskError_(runtime, error);
+    } catch (std::exception& ex) {
+      jsi::JSError error(
+          runtime, std::string("Non-JS exception: ") + ex.what());
+      onTaskError_(runtime, error);
+    }
+  }
+
   // This is the integration of the Intersection Observer API in the Event Loop.
   // See
   if (intersectionObserverDelegate_ != nullptr) {
@@ -399,7 +427,7 @@ void RuntimeScheduler_Modern::executeTask(
   } catch (jsi::JSError& error) {
     handleTaskError(runtime, error);
   } catch (std::exception& ex) {
-    jsi::JSError error(runtime, std::string("Non-js exception: ") + ex.what());
+    jsi::JSError error(runtime, std::string("Non-JS exception: ") + ex.what());
     handleTaskError(runtime, error);
   }
 }
@@ -439,7 +467,7 @@ void RuntimeScheduler_Modern::performMicrotaskCheckpoint(
       handleTaskError(runtime, error);
     } catch (std::exception& ex) {
       jsi::JSError error(
-          runtime, std::string("Non-js exception: ") + ex.what());
+          runtime, std::string("Non-JS exception: ") + ex.what());
       handleTaskError(runtime, error);
     }
     retries++;
@@ -469,9 +497,7 @@ void RuntimeScheduler_Modern::reportLongTasks(
 void RuntimeScheduler_Modern::handleTaskError(
     jsi::Runtime& runtime,
     jsi::JSError& error) {
-  if (ReactNativeFeatureFlags::enableRuntimeSchedulerQueueClearingOnError()) {
-    clearQueues();
-  }
+  clearQueues();
 
   onTaskError_(runtime, error);
 }

package/ReactCommon/react/renderer/runtimescheduler/RuntimeScheduler_Modern.h

@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include <react/cxxstableapi/FrameworksGuard.h>
+
 #include <ReactCommon/RuntimeExecutor.h>
 #include <react/renderer/consistency/ShadowTreeRevisionConsistencyManager.h>
 #include <react/renderer/runtimescheduler/RuntimeScheduler.h>
@@ -151,6 +153,8 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
   void setIntersectionObserverDelegate(
       RuntimeSchedulerIntersectionObserverDelegate *intersectionObserverDelegate) override;
 
+  void setResizeObserverDelegate(RuntimeSchedulerResizeObserverDelegate *resizeObserverDelegate) override;
+
  private:
   /// Monotonic counter handing out IDs for IEventLoopControl task queue
   /// sources.
@@ -191,7 +195,7 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
 
   void executeTask(jsi::Runtime &runtime, Task &task, bool didUserCallbackTimeout);
 
-  void updateRendering(HighResTimeStamp taskEndTime);
+  void updateRendering(jsi::Runtime &runtime, HighResTimeStamp taskEndTime);
 
   void handleTaskError(jsi::Runtime &runtime, jsi::JSError &error);
 
@@ -225,6 +229,7 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
 
   PerformanceEntryReporter *performanceEntryReporter_{nullptr};
   RuntimeSchedulerIntersectionObserverDelegate *intersectionObserverDelegate_{nullptr};
+  RuntimeSchedulerResizeObserverDelegate *resizeObserverDelegate_{nullptr};
 
   RuntimeSchedulerTaskErrorHandler onTaskError_;
 };