react-native-tvos 0.81.4-0 → 0.82.0-0

package/ReactCommon/react/nativemodule/core/tests/TurboModuleTestFixture.h

@@ -0,0 +1,135 @@
+/*
+ * 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 <ReactCommon/TestCallInvoker.h>
+#include <gtest/gtest.h>
+#include <hermes/hermes.h>
+#include <react/bridging/Bridging.h>
+#include <react/debug/react_native_assert.h>
+#include <memory>
+#include <optional>
+
+namespace facebook::react {
+class TurboModule;
+
+template <typename T, typename... Args>
+class TurboModuleTestFixture : public ::testing::Test {
+  static_assert(
+      std::is_base_of<TurboModule, T>::value,
+      "T must be derived from TurboModule");
+
+ public:
+  explicit TurboModuleTestFixture(Args... args)
+      : runtime_(hermes::makeHermesRuntime()),
+        jsInvoker_(std::make_shared<TestCallInvoker>(*runtime_)),
+        module_(std::make_shared<T>(jsInvoker_, std::forward<Args>(args)...)) {}
+
+  void SetUp() override {
+    auto setImmediateName =
+        jsi::PropNameID::forAscii(*runtime_, "setImmediate");
+    runtime_->global().setProperty(
+        *runtime_,
+        setImmediateName,
+        jsi::Function::createFromHostFunction(
+            *runtime_,
+            setImmediateName,
+            1,
+            [jsInvoker = jsInvoker_](
+                jsi::Runtime& rt,
+                [[maybe_unused]] const jsi::Value& thisVal,
+                const jsi::Value* args,
+                size_t count) {
+              react_native_assert(count >= 1);
+              jsInvoker->invokeAsync([cb = std::make_shared<jsi::Value>(
+                                          rt, args[0])](jsi::Runtime& rt) {
+                cb->asObject(rt).asFunction(rt).call(rt);
+              });
+              return jsi::Value::undefined();
+            }));
+  }
+
+  void TearDown() override {
+    module_ = nullptr;
+    jsInvoker_ = nullptr;
+    runtime_ = nullptr;
+  }
+
+  template <typename TPromise>
+  std::optional<TPromise> resolvePromise(
+      const AsyncPromise<TPromise>& asyncPromise) {
+    auto promise = asyncPromise.get(*runtime_);
+    std::optional<TPromise> result = std::nullopt;
+    promise.getPropertyAsFunction(*runtime_, "then")
+        .callWithThis(
+            *runtime_,
+            promise,
+            bridging::toJs(
+                *runtime_,
+                [&](TPromise value) { result = std::move(value); },
+                jsInvoker_));
+    jsInvoker_->flushQueue();
+    return result;
+  }
+
+  template <typename TPromise>
+  std::optional<std::string> handleError(
+      const AsyncPromise<TPromise>& asyncPromise) {
+    auto promise = asyncPromise.get(*runtime_);
+    std::optional<std::string> message;
+    promise.getPropertyAsFunction(*runtime_, "catch")
+        .callWithThis(
+            *runtime_,
+            promise,
+            bridging::toJs(
+                *runtime_,
+                [&](jsi::Object error) {
+                  message = bridging::fromJs<std::string>(
+                      *runtime_,
+                      error.getProperty(*runtime_, "message"),
+                      jsInvoker_);
+                },
+                jsInvoker_));
+    jsInvoker_->flushQueue();
+    return message;
+  }
+
+  template <typename TEvent>
+  AsyncCallback<TEvent> makeAsyncCallback(
+      std::function<void(TEvent)>&& callback) {
+    auto func = jsi::Function::createFromHostFunction(
+        *runtime_,
+        jsi::PropNameID::forAscii(*runtime_, "callback"),
+        1,
+        [jsInvoker = jsInvoker_, callback = std::move(callback)](
+            jsi::Runtime& rt,
+            [[maybe_unused]] const jsi::Value& thisVal,
+            const jsi::Value* args,
+            size_t count) {
+          if (count < 1) {
+            throw jsi::JSINativeException("callback: Missing argument");
+          }
+          callback(
+              Bridging<TEvent>::fromJs(rt, args[0].asObject(rt), jsInvoker));
+          return jsi::Value::undefined();
+        });
+    return {*runtime_, std::move(func), jsInvoker_};
+  }
+
+  void expectAndFlushQueue(size_t queueSize) {
+    EXPECT_EQ(jsInvoker_->queueSize(), queueSize);
+    jsInvoker_->flushQueue();
+  }
+
+ protected:
+  std::shared_ptr<jsi::Runtime> runtime_{};
+  std::shared_ptr<TestCallInvoker> jsInvoker_{};
+  std::shared_ptr<T> module_;
+};
+
+} // namespace facebook::react

package/ReactCommon/react/nativemodule/defaults/CMakeLists.txt

@@ -21,6 +21,7 @@ target_link_libraries(react_nativemodule_defaults
         react_nativemodule_featureflags
         react_nativemodule_microtasks
         react_nativemodule_idlecallbacks
+        react_nativemodule_webperformance
 )
 target_compile_reactnative_options(react_nativemodule_defaults PRIVATE)
 target_compile_options(react_nativemodule_defaults PRIVATE -Wpedantic)

package/ReactCommon/react/nativemodule/defaults/DefaultTurboModules.cpp

@@ -6,10 +6,12 @@
  */
 
 #include "DefaultTurboModules.h"
+#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/nativemodule/dom/NativeDOM.h>
 #include <react/nativemodule/featureflags/NativeReactNativeFeatureFlags.h>
 #include <react/nativemodule/idlecallbacks/NativeIdleCallbacks.h>
 #include <react/nativemodule/microtasks/NativeMicrotasks.h>
+#include <react/nativemodule/webperformance/NativePerformance.h>
 
 #ifdef REACT_NATIVE_DEBUGGER_ENABLED_DEVONLY
 #include <react/nativemodule/devtoolsruntimesettings/DevToolsRuntimeSettingsModule.h>
@@ -36,6 +38,12 @@ namespace facebook::react {
     return std::make_shared<NativeDOM>(jsInvoker);
   }
 
+  if (ReactNativeFeatureFlags::enableWebPerformanceAPIsByDefault()) {
+    if (name == NativePerformance::kModuleName) {
+      return std::make_shared<NativePerformance>(jsInvoker);
+    }
+  }
+
 #ifdef REACT_NATIVE_DEBUGGER_ENABLED_DEVONLY
   if (name == DevToolsRuntimeSettingsModule::kModuleName) {
     return std::make_shared<DevToolsRuntimeSettingsModule>(jsInvoker);

package/ReactCommon/react/nativemodule/defaults/React-defaultsnativemodule.podspec

@@ -50,5 +50,6 @@ Pod::Spec.new do |s|
   s.dependency "React-featureflagsnativemodule"
   s.dependency "React-microtasksnativemodule"
   s.dependency "React-idlecallbacksnativemodule"
+  s.dependency "React-webperformancenativemodule"
   add_dependency(s, "React-RCTFBReactNativeSpec")
 end

package/ReactCommon/react/nativemodule/dom/NativeDOM.cpp

@@ -30,15 +30,14 @@ inline std::shared_ptr<const ShadowNode> getShadowNode(
   return Bridging<std::shared_ptr<const ShadowNode>>::fromJs(
       runtime, shadowNodeValue);
 }
-} // namespace
 
 #pragma mark - Private helpers
 
-static UIManager& getUIManagerFromRuntime(facebook::jsi::Runtime& runtime) {
+UIManager& getUIManagerFromRuntime(facebook::jsi::Runtime& runtime) {
   return UIManagerBinding::getBinding(runtime)->getUIManager();
 }
 
-static RootShadowNode::Shared getCurrentShadowTreeRevision(
+RootShadowNode::Shared getCurrentShadowTreeRevision(
     facebook::jsi::Runtime& runtime,
     SurfaceId surfaceId) {
   auto shadowTreeRevisionProvider =
@@ -46,7 +45,7 @@ static RootShadowNode::Shared getCurrentShadowTreeRevision(
   return shadowTreeRevisionProvider->getCurrentRevision(surfaceId);
 }
 
-static RootShadowNode::Shared getCurrentShadowTreeRevision(
+RootShadowNode::Shared getCurrentShadowTreeRevision(
     facebook::jsi::Runtime& runtime,
     jsi::Value& nativeNodeReference) {
   if (nativeNodeReference.isNumber()) {
@@ -58,14 +57,13 @@ static RootShadowNode::Shared getCurrentShadowTreeRevision(
       runtime, getShadowNode(runtime, nativeNodeReference)->getSurfaceId());
 }
 
-static facebook::react::PointerEventsProcessor&
-getPointerEventsProcessorFromRuntime(facebook::jsi::Runtime& runtime) {
+facebook::react::PointerEventsProcessor& getPointerEventsProcessorFromRuntime(
+    facebook::jsi::Runtime& runtime) {
   return facebook::react::UIManagerBinding::getBinding(runtime)
       ->getPointerEventsProcessor();
 }
 
-static std::vector<facebook::jsi::Value>
-getArrayOfInstanceHandlesFromShadowNodes(
+std::vector<facebook::jsi::Value> getArrayOfInstanceHandlesFromShadowNodes(
     const std::vector<std::shared_ptr<const ShadowNode>>& nodes,
     facebook::jsi::Runtime& runtime) {
   // JSI doesn't support adding elements to an array after creation,
@@ -83,10 +81,12 @@ getArrayOfInstanceHandlesFromShadowNodes(
   return nonNullInstanceHandles;
 }
 
-static bool isRootShadowNode(const ShadowNode& shadowNode) {
+bool isRootShadowNode(const ShadowNode& shadowNode) {
   return shadowNode.getTraits().check(ShadowNodeTraits::Trait::RootNodeKind);
 }
 
+} // namespace
+
 #pragma mark - NativeDOM
 
 NativeDOM::NativeDOM(std::shared_ptr<CallInvoker> jsInvoker)
@@ -172,6 +172,23 @@ std::vector<jsi::Value> NativeDOM::getChildNodes(
   return getArrayOfInstanceHandlesFromShadowNodes(childNodes, rt);
 }
 
+jsi::Value NativeDOM::getElementById(
+    jsi::Runtime& rt,
+    SurfaceId surfaceId,
+    const std::string& id) {
+  auto currentRevision = getCurrentShadowTreeRevision(rt, surfaceId);
+  if (currentRevision == nullptr) {
+    return jsi::Value::undefined();
+  }
+
+  auto elementById = dom::getElementById(currentRevision, id);
+  if (elementById == nullptr) {
+    return jsi::Value::undefined();
+  }
+
+  return elementById->getInstanceHandle(rt);
+}
+
 jsi::Value NativeDOM::getParentNode(
     jsi::Runtime& rt,
     jsi::Value nativeNodeReference) {
@@ -299,7 +316,7 @@ NativeDOM::getScrollSize(
 }
 
 std::string NativeDOM::getTagName(
-    jsi::Runtime& rt,
+    jsi::Runtime& /*rt*/,
     std::shared_ptr<const ShadowNode> shadowNode) {
   return dom::getTagName(*shadowNode);
 }
@@ -389,44 +406,38 @@ jsi::Value NativeDOM::linkRootNode(
 void NativeDOM::measure(
     jsi::Runtime& rt,
     std::shared_ptr<const ShadowNode> shadowNode,
-    jsi::Function callback) {
+    const MeasureOnSuccessCallback& callback) {
   auto currentRevision =
       getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
   if (currentRevision == nullptr) {
-    callback.call(rt, {0, 0, 0, 0, 0, 0});
+    callback(0, 0, 0, 0, 0, 0);
     return;
   }
 
   auto measureRect = dom::measure(currentRevision, *shadowNode);
 
-  callback.call(
-      rt,
-      {jsi::Value{rt, measureRect.x},
-       jsi::Value{rt, measureRect.y},
-       jsi::Value{rt, measureRect.width},
-       jsi::Value{rt, measureRect.height},
-       jsi::Value{rt, measureRect.pageX},
-       jsi::Value{rt, measureRect.pageY}});
+  callback(
+      measureRect.x,
+      measureRect.y,
+      measureRect.width,
+      measureRect.height,
+      measureRect.pageX,
+      measureRect.pageY);
 }
 
 void NativeDOM::measureInWindow(
     jsi::Runtime& rt,
     std::shared_ptr<const ShadowNode> shadowNode,
-    jsi::Function callback) {
+    const MeasureInWindowOnSuccessCallback& callback) {
   auto currentRevision =
       getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
   if (currentRevision == nullptr) {
-    callback.call(rt, {0, 0, 0, 0});
+    callback(0, 0, 0, 0);
     return;
   }
 
   auto rect = dom::measureInWindow(currentRevision, *shadowNode);
-  callback.call(
-      rt,
-      {jsi::Value{rt, rect.x},
-       jsi::Value{rt, rect.y},
-       jsi::Value{rt, rect.width},
-       jsi::Value{rt, rect.height}});
+  callback(rect.x, rect.y, rect.width, rect.height);
 }
 
 void NativeDOM::measureLayout(
@@ -434,7 +445,7 @@ void NativeDOM::measureLayout(
     std::shared_ptr<const ShadowNode> shadowNode,
     std::shared_ptr<const ShadowNode> relativeToShadowNode,
     jsi::Function onFail,
-    jsi::Function onSuccess) {
+    const MeasureLayoutOnSuccessCallback& onSuccess) {
   auto currentRevision =
       getCurrentShadowTreeRevision(rt, shadowNode->getSurfaceId());
   if (currentRevision == nullptr) {
@@ -452,12 +463,7 @@ void NativeDOM::measureLayout(
 
   auto rect = maybeRect.value();
 
-  onSuccess.call(
-      rt,
-      {jsi::Value{rt, rect.x},
-       jsi::Value{rt, rect.y},
-       jsi::Value{rt, rect.width},
-       jsi::Value{rt, rect.height}});
+  onSuccess(rect.x, rect.y, rect.width, rect.height);
 }
 
 #pragma mark - Legacy direct manipulation APIs (for `ReactNativeElement`).

package/ReactCommon/react/nativemodule/dom/NativeDOM.h

@@ -21,6 +21,15 @@
 
 namespace facebook::react {
 
+using MeasureOnSuccessCallback =
+    SyncCallback<void(double, double, double, double, double, double)>;
+
+using MeasureInWindowOnSuccessCallback =
+    SyncCallback<void(double, double, double, double)>;
+
+using MeasureLayoutOnSuccessCallback =
+    SyncCallback<void(double, double, double, double)>;
+
 class NativeDOM : public NativeDOMCxxSpec<NativeDOM> {
  public:
   NativeDOM(std::shared_ptr<CallInvoker> jsInvoker);
@@ -36,6 +45,9 @@ class NativeDOM : public NativeDOMCxxSpec<NativeDOM> {
       jsi::Runtime& rt,
       jsi::Value nativeNodeReference);
 
+  jsi::Value
+  getElementById(jsi::Runtime& rt, SurfaceId surfaceId, const std::string& id);
+
   jsi::Value getParentNode(jsi::Runtime& rt, jsi::Value nativeNodeReference);
 
   bool isConnected(jsi::Runtime& rt, jsi::Value nativeNodeReference);
@@ -117,19 +129,19 @@ class NativeDOM : public NativeDOMCxxSpec<NativeDOM> {
   void measure(
       jsi::Runtime& rt,
       std::shared_ptr<const ShadowNode> shadowNode,
-      jsi::Function callback);
+      const MeasureOnSuccessCallback& callback);
 
   void measureInWindow(
       jsi::Runtime& rt,
       std::shared_ptr<const ShadowNode> shadowNode,
-      jsi::Function callback);
+      const MeasureInWindowOnSuccessCallback& callback);
 
   void measureLayout(
       jsi::Runtime& rt,
       std::shared_ptr<const ShadowNode> shadowNode,
       std::shared_ptr<const ShadowNode> relativeToShadowNode,
       jsi::Function onFail,
-      jsi::Function onSuccess);
+      const MeasureLayoutOnSuccessCallback& onSuccess);
 
 #pragma mark - Legacy direct manipulation APIs (for `ReactNativeElement`).
 

package/ReactCommon/react/nativemodule/featureflags/NativeReactNativeFeatureFlags.cpp

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<45e1b08fd2438b27af82591b5cfa5744>>
+ * @generated SignedSource<<e95a083880ecb122d04f210bb05d404f>>
  */
 
 /**
@@ -49,9 +49,9 @@ bool NativeReactNativeFeatureFlags::commonTestFlagWithoutNativeImplementation(
   return false;
 }
 
-bool NativeReactNativeFeatureFlags::animatedShouldSignalBatch(
+bool NativeReactNativeFeatureFlags::cdpInteractionMetricsEnabled(
     jsi::Runtime& /*runtime*/) {
-  return ReactNativeFeatureFlags::animatedShouldSignalBatch();
+  return ReactNativeFeatureFlags::cdpInteractionMetricsEnabled();
 }
 
 bool NativeReactNativeFeatureFlags::cxxNativeAnimatedEnabled(
@@ -64,9 +64,9 @@ bool NativeReactNativeFeatureFlags::cxxNativeAnimatedRemoveJsSync(
   return ReactNativeFeatureFlags::cxxNativeAnimatedRemoveJsSync();
 }
 
-bool NativeReactNativeFeatureFlags::disableMainQueueSyncDispatchIOS(
+bool NativeReactNativeFeatureFlags::disableFabricCommitInCXXAnimated(
     jsi::Runtime& /*runtime*/) {
-  return ReactNativeFeatureFlags::disableMainQueueSyncDispatchIOS();
+  return ReactNativeFeatureFlags::disableFabricCommitInCXXAnimated();
 }
 
 bool NativeReactNativeFeatureFlags::disableMountItemReorderingAndroid(
@@ -74,6 +74,11 @@ bool NativeReactNativeFeatureFlags::disableMountItemReorderingAndroid(
   return ReactNativeFeatureFlags::disableMountItemReorderingAndroid();
 }
 
+bool NativeReactNativeFeatureFlags::disableOldAndroidAttachmentMetricsWorkarounds(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::disableOldAndroidAttachmentMetricsWorkarounds();
+}
+
 bool NativeReactNativeFeatureFlags::disableTextLayoutManagerCacheAndroid(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::disableTextLayoutManagerCacheAndroid();
@@ -119,6 +124,11 @@ bool NativeReactNativeFeatureFlags::enableDoubleMeasurementFixAndroid(
   return ReactNativeFeatureFlags::enableDoubleMeasurementFixAndroid();
 }
 
+bool NativeReactNativeFeatureFlags::enableEagerMainQueueModulesOnIOS(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::enableEagerMainQueueModulesOnIOS();
+}
+
 bool NativeReactNativeFeatureFlags::enableEagerRootViewAttachment(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::enableEagerRootViewAttachment();
@@ -134,11 +144,6 @@ bool NativeReactNativeFeatureFlags::enableFabricRenderer(
   return ReactNativeFeatureFlags::enableFabricRenderer();
 }
 
-bool NativeReactNativeFeatureFlags::enableFixForParentTagDuringReparenting(
-    jsi::Runtime& /*runtime*/) {
-  return ReactNativeFeatureFlags::enableFixForParentTagDuringReparenting();
-}
-
 bool NativeReactNativeFeatureFlags::enableFontScaleChangesUpdatingLayout(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::enableFontScaleChangesUpdatingLayout();
@@ -154,6 +159,16 @@ bool NativeReactNativeFeatureFlags::enableIOSViewClipToPaddingBox(
   return ReactNativeFeatureFlags::enableIOSViewClipToPaddingBox();
 }
 
+bool NativeReactNativeFeatureFlags::enableImagePrefetchingAndroid(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::enableImagePrefetchingAndroid();
+}
+
+bool NativeReactNativeFeatureFlags::enableImmediateUpdateModeForContentOffsetChanges(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::enableImmediateUpdateModeForContentOffsetChanges();
+}
+
 bool NativeReactNativeFeatureFlags::enableInteropViewManagerClassLookUpOptimizationIOS(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::enableInteropViewManagerClassLookUpOptimizationIOS();
@@ -174,11 +189,6 @@ bool NativeReactNativeFeatureFlags::enableMainQueueCoordinatorOnIOS(
   return ReactNativeFeatureFlags::enableMainQueueCoordinatorOnIOS();
 }
 
-bool NativeReactNativeFeatureFlags::enableMainQueueModulesOnIOS(
-    jsi::Runtime& /*runtime*/) {
-  return ReactNativeFeatureFlags::enableMainQueueModulesOnIOS();
-}
-
 bool NativeReactNativeFeatureFlags::enableModuleArgumentNSNullConversionIOS(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::enableModuleArgumentNSNullConversionIOS();
@@ -214,11 +224,6 @@ bool NativeReactNativeFeatureFlags::enableResourceTimingAPI(
   return ReactNativeFeatureFlags::enableResourceTimingAPI();
 }
 
-bool NativeReactNativeFeatureFlags::enableSynchronousStateUpdates(
-    jsi::Runtime& /*runtime*/) {
-  return ReactNativeFeatureFlags::enableSynchronousStateUpdates();
-}
-
 bool NativeReactNativeFeatureFlags::enableViewCulling(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::enableViewCulling();
@@ -229,6 +234,11 @@ bool NativeReactNativeFeatureFlags::enableViewRecycling(
   return ReactNativeFeatureFlags::enableViewRecycling();
 }
 
+bool NativeReactNativeFeatureFlags::enableViewRecyclingForScrollView(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::enableViewRecyclingForScrollView();
+}
+
 bool NativeReactNativeFeatureFlags::enableViewRecyclingForText(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::enableViewRecyclingForText();
@@ -254,6 +264,11 @@ bool NativeReactNativeFeatureFlags::enableVirtualViewWindowFocusDetection(
   return ReactNativeFeatureFlags::enableVirtualViewWindowFocusDetection();
 }
 
+bool NativeReactNativeFeatureFlags::enableWebPerformanceAPIsByDefault(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::enableWebPerformanceAPIsByDefault();
+}
+
 bool NativeReactNativeFeatureFlags::fixMappingOfEventPrioritiesBetweenFabricAndReact(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::fixMappingOfEventPrioritiesBetweenFabricAndReact();
@@ -274,6 +289,11 @@ bool NativeReactNativeFeatureFlags::hideOffscreenVirtualViewsOnIOS(
   return ReactNativeFeatureFlags::hideOffscreenVirtualViewsOnIOS();
 }
 
+bool NativeReactNativeFeatureFlags::perfMonitorV2Enabled(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::perfMonitorV2Enabled();
+}
+
 double NativeReactNativeFeatureFlags::preparedTextCacheSize(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::preparedTextCacheSize();
@@ -284,6 +304,26 @@ bool NativeReactNativeFeatureFlags::preventShadowTreeCommitExhaustion(
   return ReactNativeFeatureFlags::preventShadowTreeCommitExhaustion();
 }
 
+bool NativeReactNativeFeatureFlags::releaseImageDataWhenConsumed(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::releaseImageDataWhenConsumed();
+}
+
+bool NativeReactNativeFeatureFlags::shouldPressibilityUseW3CPointerEventsForHover(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::shouldPressibilityUseW3CPointerEventsForHover();
+}
+
+bool NativeReactNativeFeatureFlags::skipActivityIdentityAssertionOnHostPause(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::skipActivityIdentityAssertionOnHostPause();
+}
+
+bool NativeReactNativeFeatureFlags::sweepActiveTouchOnChildNativeGesturesAndroid(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::sweepActiveTouchOnChildNativeGesturesAndroid();
+}
+
 bool NativeReactNativeFeatureFlags::traceTurboModulePromiseRejectionsOnAndroid(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::traceTurboModulePromiseRejectionsOnAndroid();
@@ -344,6 +384,11 @@ bool NativeReactNativeFeatureFlags::useTurboModules(
   return ReactNativeFeatureFlags::useTurboModules();
 }
 
+double NativeReactNativeFeatureFlags::virtualViewHysteresisRatio(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::virtualViewHysteresisRatio();
+}
+
 double NativeReactNativeFeatureFlags::virtualViewPrerenderRatio(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::virtualViewPrerenderRatio();