react-native-tvos 0.79.2-0 → 0.80.0-0

package/ReactCommon/react/runtime/React-RuntimeHermes.podspec

@@ -16,14 +16,6 @@ else
   source[:tag] = "v#{version}"
 end
 
-folly_config = get_folly_config()
-folly_compiler_flags = folly_config[:compiler_flags]
-folly_version = folly_config[:version]
-folly_dep_name = folly_config[:dep_name]
-
-boost_config = get_boost_config()
-boost_compiler_flags = boost_config[:compiler_flags]
-
 Pod::Spec.new do |s|
   s.name                   = "React-RuntimeHermes"
   s.version                = version
@@ -35,27 +27,28 @@ Pod::Spec.new do |s|
   s.source                 = source
   s.source_files           = "hermes/*.{cpp,h}"
   s.header_dir             = "react/runtime/hermes"
-  s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"${PODS_TARGET_SRCROOT}/../..\" \"${PODS_TARGET_SRCROOT}/../../hermes/executor\" \"$(PODS_ROOT)/boost\"",
+  s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"${PODS_TARGET_SRCROOT}/../..\" \"${PODS_TARGET_SRCROOT}/../../hermes/executor\"",
                                 "USE_HEADERMAP" => "YES",
                                 "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
                                 "GCC_WARN_PEDANTIC" => "YES" }
-  s.compiler_flags       = folly_compiler_flags + ' ' + boost_compiler_flags
 
   if ENV['USE_FRAMEWORKS']
     s.header_mappings_dir     = '../../'
     s.module_name             = 'React_RuntimeHermes'
   end
 
-  s.dependency folly_dep_name, folly_version
   s.dependency "React-jsitracing"
   s.dependency "React-jsi"
   s.dependency "React-utils"
   s.dependency "React-RuntimeCore"
   s.dependency "React-featureflags"
   add_dependency(s, "React-jsinspector", :framework_name => 'jsinspector_modern')
+  add_dependency(s, "React-jsinspectorcdp", :framework_name => 'jsinspector_moderncdp')
   add_dependency(s, "React-jsinspectortracing", :framework_name => 'jsinspector_moderntracing')
 
   s.dependency "React-hermes"
   s.dependency "hermes-engine"
   add_dependency(s, "React-jsitooling", :framework_name => "JSITooling")
+
+  add_rn_third_party_dependencies(s)
 end

package/ReactCommon/react/runtime/ReactInstance.cpp

@@ -215,7 +215,8 @@ std::string simpleBasename(const std::string& path) {
 void ReactInstance::loadScript(
     std::unique_ptr<const JSBigString> script,
     const std::string& sourceURL,
-    std::function<void(jsi::Runtime& runtime)>&& completion) {
+    std::function<void(jsi::Runtime& runtime)>&& beforeLoad,
+    std::function<void(jsi::Runtime& runtime)>&& afterLoad) {
   auto buffer = std::make_shared<BigStringBuffer>(std::move(script));
   std::string scriptName = simpleBasename(sourceURL);
 
@@ -226,7 +227,11 @@ void ReactInstance::loadScript(
                                    weakBufferedRuntimeExecuter =
                                        std::weak_ptr<BufferedRuntimeExecutor>(
                                            bufferedRuntimeExecutor_),
-                                   completion](jsi::Runtime& runtime) {
+                                   beforeLoad,
+                                   afterLoad](jsi::Runtime& runtime) {
+    if (beforeLoad) {
+      beforeLoad(runtime);
+    }
     TraceSection s("ReactInstance::loadScript");
     bool hasLogger(ReactMarker::logTaggedMarkerBridgelessImpl);
     if (hasLogger) {
@@ -255,8 +260,8 @@ void ReactInstance::loadScript(
             weakBufferedRuntimeExecuter.lock()) {
       strongBufferedRuntimeExecuter->flush();
     }
-    if (completion) {
-      completion(runtime);
+    if (afterLoad) {
+      afterLoad(runtime);
     }
   });
 }
@@ -330,7 +335,7 @@ void ReactInstance::registerSegment(
                << segmentId;
   runtimeScheduler_->scheduleWork([=](jsi::Runtime& runtime) {
     TraceSection s("ReactInstance::registerSegment");
-    const auto tag = folly::to<std::string>(segmentId);
+    auto tag = std::to_string(segmentId);
     auto script = JSBigFileString::fromPath(segmentPath);
     if (script->size() == 0) {
       throw std::invalid_argument(

package/ReactCommon/react/runtime/ReactInstance.h

@@ -50,7 +50,8 @@ class ReactInstance final : private jsinspector_modern::InstanceTargetDelegate {
   void loadScript(
       std::unique_ptr<const JSBigString> script,
       const std::string& sourceURL,
-      std::function<void(jsi::Runtime& runtime)>&& completion = nullptr);
+      std::function<void(jsi::Runtime& runtime)>&& beforeLoad = nullptr,
+      std::function<void(jsi::Runtime& runtime)>&& afterLoad = nullptr);
 
   void registerSegment(uint32_t segmentId, const std::string& segmentPath);
 

package/ReactCommon/react/runtime/TimerManager.cpp

@@ -242,8 +242,9 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
             }
 
             if (!args[0].isObject() || !args[0].asObject(rt).isFunction(rt)) {
-              // Do not throw any error to match web spec
-              return timerIndex_++;
+              // Do not throw any error to match web spec; instead return 0, an
+              // invalid timer id
+              return 0;
             }
 
             auto callback = args[0].getObject(rt).getFunction(rt);
@@ -300,8 +301,9 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
             }
 
             if (!args[0].isObject() || !args[0].asObject(rt).isFunction(rt)) {
-              throw jsi::JSError(
-                  rt, "The first argument to setInterval must be a function.");
+              // Do not throw any error to match web spec; instead return 0, an
+              // invalid timer id
+              return 0;
             }
             auto callback = args[0].getObject(rt).getFunction(rt);
             auto delay = count > 1

package/ReactCommon/react/runtime/TimerManager.h

@@ -93,7 +93,9 @@ class TimerManager {
 
   // Each timeout that is registered on this queue gets a sequential id.  This
   // is the global count from which those are assigned.
-  TimerHandle timerIndex_{0};
+  // As per WHATWG HTML 8.6.1 (Timers) ids must be greater than zero, i.e. start
+  // at 1
+  TimerHandle timerIndex_{1};
 
   // The React Native microtask queue is used to back public APIs including
   // `queueMicrotask`, `clearImmediate`, and `setImmediate` (which is used by

package/ReactCommon/react/runtime/hermes/CMakeLists.txt

@@ -6,7 +6,7 @@
 cmake_minimum_required(VERSION 3.13)
 set(CMAKE_VERBOSE_MAKEFILE on)
 
-add_compile_options(-std=c++20)
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
 
 file(GLOB_RECURSE bridgeless_hermes_SRC CONFIGURE_DEPENDS *.cpp)
 add_library(
@@ -25,6 +25,7 @@ target_link_libraries(bridgelesshermes
         reactnative
 )
 
+target_compile_reactnative_options(bridgelesshermes PRIVATE "Fabric")
 if(${CMAKE_BUILD_TYPE} MATCHES Debug)
         target_compile_options(
                 bridgelesshermes

package/ReactCommon/react/runtime/iostests/RCTHostTests.mm

@@ -15,6 +15,7 @@
 #import <ReactCommon/RCTHost.h>
 #import <ReactCommon/RCTInstance.h>
 #import <ReactCommon/RCTTurboModuleManager.h>
+#import <hermes/hermes.h>
 
 #import <OCMock/OCMock.h>
 

package/ReactCommon/react/runtime/nativeviewconfig/CMakeLists.txt

@@ -6,7 +6,7 @@
 cmake_minimum_required(VERSION 3.13)
 set(CMAKE_VERBOSE_MAKEFILE on)
 
-add_compile_options(-std=c++20)
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
 
 file(GLOB_RECURSE bridgeless_nativeviewconfig_SRC CONFIGURE_DEPENDS *.cpp)
 add_library(
@@ -17,3 +17,4 @@ add_library(
 target_include_directories(bridgelessnativeviewconfig PUBLIC .)
 
 target_link_libraries(bridgelessnativeviewconfig jsi)
+target_compile_reactnative_options(bridgelessnativeviewconfig PRIVATE)

package/ReactCommon/react/runtime/platform/ios/React-RuntimeApple.podspec

@@ -16,16 +16,7 @@ else
   source[:tag] = "v#{version}"
 end
 
-folly_config = get_folly_config()
-folly_compiler_flags = folly_config[:compiler_flags]
-folly_version = folly_config[:version]
-folly_dep_name = folly_config[:dep_name]
-
-boost_config = get_boost_config()
-boost_compiler_flags = boost_config[:compiler_flags]
-
 header_search_paths = [
-  "$(PODS_ROOT)/boost",
   "$(PODS_ROOT)/Headers/Private/React-Core",
   "$(PODS_TARGET_SRCROOT)/../../../..",
   "$(PODS_TARGET_SRCROOT)/../../../../..",
@@ -46,14 +37,12 @@ Pod::Spec.new do |s|
                                 "USE_HEADERMAP" => "YES",
                                 "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
                                 "GCC_WARN_PEDANTIC" => "YES" }
-  s.compiler_flags       = folly_compiler_flags + ' ' + boost_compiler_flags
 
   if ENV['USE_FRAMEWORKS']
     s.header_mappings_dir     = './'
     s.module_name             = 'React_RuntimeApple'
   end
 
-  s.dependency folly_dep_name, folly_version
   s.dependency "React-jsiexecutor"
   s.dependency "React-cxxreact"
   s.dependency "React-callinvoker"
@@ -83,4 +72,6 @@ Pod::Spec.new do |s|
     s.dependency "React-jsc"
     s.exclude_files = "ReactCommon/RCTHermesInstance.{mm,h}"
   end
+
+  add_rn_third_party_dependencies(s)
 end

package/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTHost.h

@@ -30,6 +30,8 @@ typedef NSURL *_Nullable (^RCTHostBundleURLProvider)(void);
 - (void)hostDidStart:(RCTHost *)host;
 
 @optional
+- (NSArray<NSString *> *)unstableModulesRequiringMainQueueSetup;
+
 - (void)loadBundleAtURL:(NSURL *)sourceURL
              onProgress:(RCTSourceLoadProgressBlock)onProgress
              onComplete:(RCTSourceLoadBlock)loadCallback;

package/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTHost.mm

@@ -12,7 +12,6 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTConvert.h>
 #import <React/RCTFabricSurface.h>
-#import <React/RCTInitializeUIKitProxies.h>
 #import <React/RCTInspectorDevServerHelper.h>
 #import <React/RCTInspectorNetworkHelper.h>
 #import <React/RCTInspectorUtils.h>
@@ -22,6 +21,7 @@
 #import <React/RCTPausedInDebuggerOverlayController.h>
 #import <React/RCTPerformanceLogger.h>
 #import <React/RCTReloadCommand.h>
+#import <React/RCTUtils.h>
 #import <jsinspector-modern/InspectorFlags.h>
 #import <jsinspector-modern/InspectorInterfaces.h>
 #import <jsinspector-modern/ReactCdp.h>
@@ -48,12 +48,17 @@ class RCTHostHostTargetDelegate : public facebook::react::jsinspector_modern::Ho
   jsinspector_modern::HostTargetMetadata getMetadata() override
   {
     auto metadata = [RCTInspectorUtils getHostMetadata];
+#if TARGET_OS_IPHONE
+    NSString *osName = [[UIDevice currentDevice] systemName];
+#else
+    NSString *osName = @"macOS";
+#endif
 
     return {
         .appDisplayName = [metadata.appDisplayName UTF8String],
         .appIdentifier = [metadata.appIdentifier UTF8String],
         .deviceName = [metadata.deviceName UTF8String],
-        .integrationName = [[NSString stringWithFormat:@"%@ Bridgeless (RCTHost)", metadata.platform] UTF8String],
+        .integrationName = [[NSString stringWithFormat:@"%@ Bridgeless (RCTHost)", osName] UTF8String],
         .platform = [metadata.platform UTF8String],
         .reactNativeVersion = [metadata.reactNativeVersion UTF8String],
     };
@@ -190,8 +195,8 @@ class RCTHostHostTargetDelegate : public facebook::react::jsinspector_modern::Ho
                                        andSetter:bundleURLSetter
                                 andDefaultGetter:defaultBundleURLGetter];
 
-    // Listen to reload commands
-    dispatch_async(dispatch_get_main_queue(), ^{
+    RCTExecuteOnMainQueue(^{
+      // Listen to reload commands
       RCTRegisterReloadCommandListener(self);
     });
 
@@ -249,7 +254,6 @@ class RCTHostHostTargetDelegate : public facebook::react::jsinspector_modern::Ho
                                              mode:(DisplayMode)displayMode
                                 initialProperties:(NSDictionary *)properties
 {
-  RCTInitializeUIKitProxies();
   RCTFabricSurface *surface = [[RCTFabricSurface alloc] initWithSurfacePresenter:self.surfacePresenter
                                                                       moduleName:moduleName
                                                                initialProperties:properties];
@@ -306,6 +310,14 @@ class RCTHostHostTargetDelegate : public facebook::react::jsinspector_modern::Ho
 
 #pragma mark - RCTInstanceDelegate
 
+- (NSArray<NSString *> *)unstableModulesRequiringMainQueueSetup
+{
+  if ([_hostDelegate respondsToSelector:@selector(unstableModulesRequiringMainQueueSetup)]) {
+    return [_hostDelegate unstableModulesRequiringMainQueueSetup];
+  }
+  return @[];
+}
+
 - (BOOL)instance:(RCTInstance *)instance
     didReceiveJSErrorStack:(NSArray<NSDictionary<NSString *, id> *> *)stack
                    message:(NSString *)message

package/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTInstance.h

@@ -43,6 +43,8 @@ RCT_EXTERN void RCTInstanceSetRuntimeDiagnosticFlags(NSString *_Nullable flags);
              onProgress:(RCTSourceLoadProgressBlock)onProgress
              onComplete:(RCTSourceLoadBlock)loadCallback;
 
+- (NSArray<NSString *> *)unstableModulesRequiringMainQueueSetup;
+
 // TODO(T205780509): Remove this api in react native v0.78
 // The bridgeless js error handling api will just call into exceptionsmanager directly
 - (BOOL)instance:(RCTInstance *)instance

package/ReactCommon/react/runtime/platform/ios/ReactCommon/RCTInstance.mm

@@ -85,6 +85,7 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
   std::atomic<bool> _valid;
   RCTJSThreadManager *_jsThreadManager;
   NSDictionary *_launchOptions;
+  void (^_waitUntilModuleSetupComplete)();
 
   // APIs supporting interop with native modules and view managers
   RCTBridgeModuleDecorator *_bridgeModuleDecorator;
@@ -314,6 +315,38 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
   // Initialize RCTModuleRegistry so that TurboModules can require other TurboModules.
   [_bridgeModuleDecorator.moduleRegistry setTurboModuleRegistry:_turboModuleManager];
 
+  if (ReactNativeFeatureFlags::enableMainQueueModulesOnIOS()) {
+    /**
+     * Some native modules need to capture uikit objects on the main thread.
+     * Start initializing those modules on the main queue here. The JavaScript thread
+     * will wait until this module init finishes, before executing the js bundle.
+     */
+    NSArray<NSString *> *modulesRequiringMainQueueSetup = [_delegate unstableModulesRequiringMainQueueSetup];
+
+    std::shared_ptr<std::mutex> mutex = std::make_shared<std::mutex>();
+    std::shared_ptr<std::condition_variable> cv = std::make_shared<std::condition_variable>();
+    std::shared_ptr<bool> isReady = std::make_shared<bool>(false);
+
+    _waitUntilModuleSetupComplete = ^{
+      std::unique_lock<std::mutex> lock(*mutex);
+      cv->wait(lock, [isReady] { return *isReady; });
+    };
+
+    // TODO(T218039767): Integrate perf logging into main queue module init
+    RCTExecuteOnMainQueue(^{
+      for (NSString *moduleName in modulesRequiringMainQueueSetup) {
+        [self->_bridgeModuleDecorator.moduleRegistry moduleForName:[moduleName UTF8String]];
+      }
+
+      RCTScreenSize();
+      RCTScreenScale();
+
+      std::lock_guard<std::mutex> lock(*mutex);
+      *isReady = true;
+      cv->notify_all();
+    });
+  }
+
   RCTLogSetBridgelessModuleRegistry(_bridgeModuleDecorator.moduleRegistry);
   RCTLogSetBridgelessCallableJSModules(_bridgeModuleDecorator.callableJSModules);
 
@@ -474,7 +507,6 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
 
         if (error) {
           [strongSelf handleBundleLoadingError:error];
-          [strongSelf invalidate];
           return;
         }
         // DevSettings module is needed by _loadScriptFromSource's callback so prior initialization is required
@@ -484,9 +516,30 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
         // Set up hot module reloading in Dev only.
         [strongSelf->_performanceLogger markStopForTag:RCTPLScriptDownload];
         [devSettings setupHMRClientWithBundleURL:sourceURL];
+#if RCT_DEV
+        [strongSelf _logOldArchitectureWarnings];
+#endif
       }];
 }
 
+- (void)_logOldArchitectureWarnings
+{
+  if (!RCTAreLegacyLogsEnabled()) {
+    return;
+  }
+
+  NSArray<NSString *> *modulesInOldArchMode = [getModulesLoadedWithOldArch() copy];
+  if (modulesInOldArchMode.count > 0) {
+    NSMutableString *moduleList = [NSMutableString new];
+    for (NSString *moduleName in modulesInOldArchMode) {
+      [moduleList appendFormat:@"- %@\n", moduleName];
+    }
+    RCTLogWarn(
+        @"The following modules have been registered using a RCT_EXPORT_MODULE. That's a Legacy Architecture API. Please migrate to the new approach as described in the https://reactnative.dev/docs/next/turbo-native-modules-introduction#register-the-native-module-in-your-app website or open a PR in the library repository:\n%@",
+        moduleList);
+  }
+}
+
 - (void)_loadScriptFromSource:(RCTSource *)source
 {
   std::lock_guard<std::mutex> lock(_invalidationMutex);
@@ -496,9 +549,16 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
 
   auto script = std::make_unique<NSDataBigString>(source.data);
   const auto *url = deriveSourceURL(source.url).UTF8String;
-  _reactInstance->loadScript(std::move(script), url, [](jsi::Runtime &_) {
+
+  auto beforeLoad = [waitUntilModuleSetupComplete = self->_waitUntilModuleSetupComplete](jsi::Runtime &_) {
+    if (waitUntilModuleSetupComplete) {
+      waitUntilModuleSetupComplete();
+    }
+  };
+  auto afterLoad = [](jsi::Runtime &_) {
     [[NSNotificationCenter defaultCenter] postNotificationName:@"RCTInstanceDidLoadBundle" object:nil];
-  });
+  };
+  _reactInstance->loadScript(std::move(script), url, beforeLoad, afterLoad);
 }
 
 - (void)_handleJSError:(const JsErrorHandler::ProcessedError &)error withRuntime:(jsi::Runtime &)runtime
@@ -548,7 +608,7 @@ void RCTInstanceSetRuntimeDiagnosticFlags(NSString *flags)
                             name:errorData[@"name"]
                   componentStack:errorData[@"componentStack"]
                      exceptionId:error.id
-                         isFatal:errorData[@"isFatal"]
+                         isFatal:[errorData[@"isFatal"] boolValue]
                        extraData:errorData[@"extraData"]]) {
     JS::NativeExceptionsManager::ExceptionData jsErrorData{errorData};
     id<NativeExceptionsManagerSpec> exceptionsManager = [_turboModuleManager moduleForName:"ExceptionsManager"];

package/ReactCommon/react/runtime/tests/cxx/ReactInstanceTest.cpp

@@ -267,7 +267,9 @@ TEST_F(ReactInstanceTest, testSetTimeoutWithoutDelay) {
   EXPECT_CALL(
       *mockRegistry_,
       createTimer(_, 0)); // If delay is not provided, it should use 0
-  eval("setTimeout(() => {});");
+  auto val = eval("setTimeout(() => {});");
+  expectNoError();
+  EXPECT_EQ(val.asNumber(), 1); // First timer id should start at 1
 }
 
 TEST_F(ReactInstanceTest, testSetTimeoutWithPassThroughArgs) {
@@ -299,8 +301,9 @@ TEST_F(ReactInstanceTest, testSetTimeoutWithInvalidArgs) {
       getErrorMessage("setTimeout();"),
       "setTimeout must be called with at least one argument (the function to call).");
 
-  eval("setTimeout('invalid');");
+  auto val = eval("setTimeout('invalid')");
   expectNoError();
+  EXPECT_EQ(val.asNumber(), 0);
 
   eval("setTimeout(() => {}, 'invalid');");
   expectNoError();
@@ -417,9 +420,10 @@ TEST_F(ReactInstanceTest, testSetIntervalWithInvalidArgs) {
   EXPECT_EQ(
       getErrorMessage("setInterval();"),
       "setInterval must be called with at least one argument (the function to call).");
-  EXPECT_EQ(
-      getErrorMessage("setInterval('invalid', 100);"),
-      "The first argument to setInterval must be a function.");
+
+  auto val = eval("setInterval('invalid', 100)");
+  expectNoError();
+  EXPECT_EQ(val.asNumber(), 0);
 }
 
 TEST_F(ReactInstanceTest, testClearInterval) {

package/ReactCommon/react/test_utils/shadowTreeGeneration.h

@@ -18,9 +18,6 @@
 #include <react/renderer/mounting/Differentiator.h>
 #include <react/renderer/mounting/stubs/stubs.h>
 
-#include <react/renderer/components/root/RootComponentDescriptor.h>
-#include <react/renderer/components/view/ViewComponentDescriptor.h>
-
 #include "Entropy.h"
 
 namespace facebook::react {

package/ReactCommon/react/timing/CMakeLists.txt

@@ -6,13 +6,10 @@
 cmake_minimum_required(VERSION 3.13)
 set(CMAKE_VERBOSE_MAKEFILE on)
 
-add_compile_options(
-        -fexceptions
-        -frtti
-        -std=c++20
-        -Wall
-        -Wpedantic)
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
 
 add_library(react_timing INTERFACE)
 
 target_include_directories(react_timing INTERFACE ${REACT_COMMON_DIR})
+target_compile_reactnative_options(react_timing INTERFACE)
+target_compile_options(react_timing INTERFACE -Wpedantic)

package/ReactCommon/react/utils/CMakeLists.txt

@@ -6,21 +6,21 @@
 cmake_minimum_required(VERSION 3.13)
 set(CMAKE_VERBOSE_MAKEFILE on)
 
-add_compile_options(
-        -fexceptions
-        -frtti
-        -std=c++20
-        -Wall
-        -Wpedantic
-        -DLOG_TAG=\"Fabric\")
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
 
-file(GLOB react_utils_SRC CONFIGURE_DEPENDS *.cpp *.mm)
+file(GLOB react_utils_SRC CONFIGURE_DEPENDS *.cpp platform/android/react/utils/*.cpp)
 add_library(react_utils OBJECT ${react_utils_SRC})
 
-target_include_directories(react_utils PUBLIC ${REACT_COMMON_DIR})
+target_include_directories(react_utils
+        PUBLIC
+          ${REACT_COMMON_DIR}
+          ${CMAKE_CURRENT_SOURCE_DIR}/platform/android/
+)
 
 target_link_libraries(react_utils
         glog
         glog_init
         jsireact
         react_debug)
+target_compile_reactnative_options(react_utils PRIVATE "Fabric")
+target_compile_options(react_utils PRIVATE -Wpedantic)

package/ReactCommon/react/utils/React-utils.podspec

@@ -16,17 +16,12 @@ else
   source[:tag] = "v#{version}"
 end
 
-folly_config = get_folly_config()
-folly_compiler_flags = folly_config[:compiler_flags]
-folly_version = folly_config[:version]
-
-header_search_paths = [
-    "\"$(PODS_ROOT)/RCT-Folly\"",
-    "\"$(PODS_TARGET_SRCROOT)\"",
-    "\"$(PODS_TARGET_SRCROOT)/ReactCommon\"",
-]
-
 Pod::Spec.new do |s|
+  source_files = "*.{m,mm,cpp,h}", "platform/ios/**/*.{m,mm,cpp,h}"
+  header_search_paths = [
+    "\"$(PODS_TARGET_SRCROOT)/../../\"",
+  ]
+
   s.name                   = "React-utils"
   s.version                = version
   s.summary                = "-"  # TODO
@@ -35,24 +30,25 @@ Pod::Spec.new do |s|
   s.author                 = "Meta Platforms, Inc. and its affiliates"
   s.platforms              = min_supported_versions
   s.source                 = source
-  s.source_files           = "**/*.{cpp,h,mm}"
-  s.compiler_flags         = folly_compiler_flags
+  s.source_files           = source_files
   s.header_dir             = "react/utils"
   s.exclude_files          = "tests"
-  s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
-                               "HEADER_SEARCH_PATHS" => header_search_paths.join(' '),
-                               "DEFINES_MODULE" => "YES" }
 
   if ENV['USE_FRAMEWORKS']
     s.module_name            = "React_utils"
     s.header_mappings_dir  = "../.."
+    header_search_paths = header_search_paths + ["\"$(PODS_TARGET_SRCROOT)/platform/ios\""]
   end
 
-  s.dependency "RCT-Folly", folly_version
+  s.pod_target_xcconfig    = { "USE_HEADERMAP" => "NO",
+                               "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
+                               "HEADER_SEARCH_PATHS" => header_search_paths.join(' '),
+                               "DEFINES_MODULE" => "YES" }
+
   s.dependency "React-jsi", version
-  s.dependency "glog"
 
   depend_on_js_engine(s)
+  add_rn_third_party_dependencies(s)
 
   add_dependency(s, "React-debug")
 end

package/ReactCommon/react/utils/platform/android/react/utils/LowPriorityExecutor.cpp

@@ -0,0 +1,95 @@
+/*
+ * 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 <pthread.h>
+#include <sched.h>
+#include <condition_variable>
+#include <mutex>
+#include <queue>
+#include <thread>
+#include <utility>
+
+namespace facebook::react::LowPriorityExecutor {
+
+struct LowPriorityExecutorThread {
+  LowPriorityExecutorThread() : thread_{std::thread([this] { run(); })} {
+    pthread_t hThread = thread_.native_handle();
+    struct sched_param param {};
+    param.sched_priority = 19; // Higher value means lower priority
+    pthread_setschedparam(hThread, SCHED_OTHER, &param);
+  }
+
+  // Deleted constructors
+  LowPriorityExecutorThread(const LowPriorityExecutorThread& other) = delete;
+  LowPriorityExecutorThread(LowPriorityExecutorThread&& other) = delete;
+  LowPriorityExecutorThread& operator=(const LowPriorityExecutorThread& other) =
+      delete;
+  LowPriorityExecutorThread& operator=(LowPriorityExecutorThread&& other) =
+      delete;
+
+  ~LowPriorityExecutorThread() {
+    // Stop the thread
+    {
+      std::lock_guard<std::mutex> lock(mutex_);
+      running_ = false;
+    }
+
+    // Unblock the thread to check the running_ flag and terminate.
+    cv_.notify_one();
+
+    // Wait for thread completion to avoid use-after-free on background thread.
+    thread_.join();
+  }
+
+  void post(std::function<void()>&& workItem) {
+    // Move the object to the queue.
+    {
+      std::lock_guard<std::mutex> lock(mutex_);
+      queue_.emplace(std::move(workItem));
+    }
+
+    // Notify the background thread.
+    cv_.notify_one();
+  }
+
+ private:
+  void run() {
+    pthread_setname_np(pthread_self(), "LowPriorityExecutorThread");
+
+    while (true) {
+      std::unique_lock<std::mutex> lock(mutex_);
+
+      // Wait until an object is in the queue or the thread is stopped.
+      cv_.wait(lock, [this] { return !queue_.empty() || !running_; });
+
+      // Empty the queue.
+      while (!queue_.empty()) {
+        queue_.front()();
+        queue_.pop();
+      }
+
+      // Check if the thread is stopping.
+      if (!running_) {
+        break;
+      }
+    }
+  }
+
+  std::string threadName_;
+  std::thread thread_;
+  std::queue<std::function<void()>> queue_;
+  std::mutex mutex_;
+  std::condition_variable cv_;
+  bool running_{true};
+};
+
+void execute(std::function<void()>&& workItem) {
+  static LowPriorityExecutorThread thread{};
+  thread.post(std::move(workItem));
+}
+
+} // namespace facebook::react::LowPriorityExecutor