react-native-tvos 0.74.3-0 → 0.75.2-0

package/ReactCommon/react/runtime/TimerManager.cpp

@@ -21,125 +21,125 @@ void TimerManager::setRuntimeExecutor(
   runtimeExecutor_ = runtimeExecutor;
 }
 
-std::shared_ptr<TimerHandle> TimerManager::createReactNativeMicrotask(
+TimerHandle TimerManager::createReactNativeMicrotask(
     jsi::Function&& callback,
     std::vector<jsi::Value>&& args) {
-  auto sharedCallback = std::make_shared<TimerCallback>(
-      std::move(callback), std::move(args), /* repeat */ false);
-
   // Get the id for the callback.
-  uint32_t timerID = timerIndex_++;
-  timers_[timerID] = std::move(sharedCallback);
+  TimerHandle timerID = timerIndex_++;
+  timers_.emplace(
+      std::piecewise_construct,
+      std::forward_as_tuple(timerID),
+      std::forward_as_tuple(
+          std::move(callback), std::move(args), /* repeat */ false));
 
   reactNativeMicrotasksQueue_.push_back(timerID);
-  return std::make_shared<TimerHandle>(timerID);
+  return timerID;
 }
 
 void TimerManager::callReactNativeMicrotasks(jsi::Runtime& runtime) {
-  std::vector<uint32_t> reactNativeMicrotasksQueue;
+  std::vector<TimerHandle> reactNativeMicrotasksQueue;
   while (!reactNativeMicrotasksQueue_.empty()) {
     reactNativeMicrotasksQueue.clear();
     reactNativeMicrotasksQueue.swap(reactNativeMicrotasksQueue_);
 
     for (auto reactNativeMicrotaskID : reactNativeMicrotasksQueue) {
       // ReactNativeMicrotasks can clear other scheduled reactNativeMicrotasks.
-      if (timers_.count(reactNativeMicrotaskID) > 0) {
-        timers_[reactNativeMicrotaskID]->invoke(runtime);
+      auto it = timers_.find(reactNativeMicrotaskID);
+      if (it != timers_.end()) {
+        it->second.invoke(runtime);
+
+        // Invoking a timer has the potential to delete it. Do not re-use the
+        // existing iterator to erase it from the map.
         timers_.erase(reactNativeMicrotaskID);
       }
     }
   }
 }
 
-std::shared_ptr<TimerHandle> TimerManager::createTimer(
+TimerHandle TimerManager::createTimer(
     jsi::Function&& callback,
     std::vector<jsi::Value>&& args,
     double delay) {
-  auto sharedCallback = std::make_shared<TimerCallback>(
-      std::move(callback), std::move(args), false);
-
   // Get the id for the callback.
-  uint32_t timerID = timerIndex_++;
-  timers_[timerID] = std::move(sharedCallback);
+  TimerHandle timerID = timerIndex_++;
+  timers_.emplace(
+      std::piecewise_construct,
+      std::forward_as_tuple(timerID),
+      std::forward_as_tuple(
+          std::move(callback), std::move(args), /* repeat */ false));
 
   platformTimerRegistry_->createTimer(timerID, delay);
 
-  return std::make_shared<TimerHandle>(timerID);
+  return timerID;
 }
 
-std::shared_ptr<TimerHandle> TimerManager::createRecurringTimer(
+TimerHandle TimerManager::createRecurringTimer(
     jsi::Function&& callback,
     std::vector<jsi::Value>&& args,
     double delay) {
-  auto sharedCallback = std::make_shared<TimerCallback>(
-      std::move(callback), std::move(args), true);
-
   // Get the id for the callback.
-  uint32_t timerID = timerIndex_++;
-  timers_[timerID] = std::move(sharedCallback);
+  TimerHandle timerID = timerIndex_++;
+  timers_.emplace(
+      std::piecewise_construct,
+      std::forward_as_tuple(timerID),
+      std::forward_as_tuple(
+          std::move(callback), std::move(args), /* repeat */ true));
 
   platformTimerRegistry_->createRecurringTimer(timerID, delay);
 
-  return std::make_shared<TimerHandle>(timerID);
+  return timerID;
 }
 
 void TimerManager::deleteReactNativeMicrotask(
     jsi::Runtime& runtime,
-    std::shared_ptr<TimerHandle> timerHandle) {
-  if (timerHandle == nullptr) {
+    TimerHandle timerHandle) {
+  if (timerHandle < 0) {
     throw jsi::JSError(
         runtime, "clearReactNativeMicrotask was called with an invalid handle");
   }
 
-  for (auto it = reactNativeMicrotasksQueue_.begin();
-       it != reactNativeMicrotasksQueue_.end();
-       it++) {
-    if ((*it) == timerHandle->index()) {
-      reactNativeMicrotasksQueue_.erase(it);
-      break;
-    }
-  }
-
-  if (timers_.find(timerHandle->index()) != timers_.end()) {
-    timers_.erase(timerHandle->index());
+  auto it = std::find(
+      reactNativeMicrotasksQueue_.begin(),
+      reactNativeMicrotasksQueue_.end(),
+      timerHandle);
+  if (it != reactNativeMicrotasksQueue_.end()) {
+    reactNativeMicrotasksQueue_.erase(it);
+    timers_.erase(timerHandle);
   }
 }
 
-void TimerManager::deleteTimer(
-    jsi::Runtime& runtime,
-    std::shared_ptr<TimerHandle> timerHandle) {
-  if (timerHandle == nullptr) {
+void TimerManager::deleteTimer(jsi::Runtime& runtime, TimerHandle timerHandle) {
+  if (timerHandle < 0) {
     throw jsi::JSError(runtime, "clearTimeout called with an invalid handle");
   }
 
-  platformTimerRegistry_->deleteTimer(timerHandle->index());
-  if (timers_.find(timerHandle->index()) != timers_.end()) {
-    timers_.erase(timerHandle->index());
-  }
+  platformTimerRegistry_->deleteTimer(timerHandle);
+  timers_.erase(timerHandle);
 }
 
 void TimerManager::deleteRecurringTimer(
     jsi::Runtime& runtime,
-    std::shared_ptr<TimerHandle> timerHandle) {
-  if (timerHandle == nullptr) {
+    TimerHandle timerHandle) {
+  if (timerHandle < 0) {
     throw jsi::JSError(runtime, "clearInterval called with an invalid handle");
   }
 
-  platformTimerRegistry_->deleteTimer(timerHandle->index());
-  if (timers_.find(timerHandle->index()) != timers_.end()) {
-    timers_.erase(timerHandle->index());
-  }
+  platformTimerRegistry_->deleteTimer(timerHandle);
+  timers_.erase(timerHandle);
 }
 
-void TimerManager::callTimer(uint32_t timerID) {
-  runtimeExecutor_([this, timerID](jsi::Runtime& runtime) {
+void TimerManager::callTimer(TimerHandle timerHandle) {
+  runtimeExecutor_([this, timerHandle](jsi::Runtime& runtime) {
     SystraceSection s("TimerManager::callTimer");
-    if (timers_.count(timerID) > 0) {
-      timers_[timerID]->invoke(runtime);
-      // Invoking a timer has the potential to delete it. Double check the timer
-      // still exists before accessing it again.
-      if (timers_.count(timerID) > 0 && !timers_[timerID]->repeat) {
-        timers_.erase(timerID);
+    auto it = timers_.find(timerHandle);
+    if (it != timers_.end()) {
+      bool repeats = it->second.repeat;
+      it->second.invoke(runtime);
+
+      if (!repeats) {
+        // Invoking a timer has the potential to delete it. Do not re-use the
+        // existing iterator to erase it from the map.
+        timers_.erase(timerHandle);
       }
     }
   });
@@ -180,9 +180,8 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
               moreArgs.emplace_back(rt, args[extraArgNum]);
             }
 
-            auto handle = createReactNativeMicrotask(
+            return createReactNativeMicrotask(
                 std::move(callback), std::move(moreArgs));
-            return jsi::Object::createFromHostObject(rt, handle);
           }));
 
   runtime.global().setProperty(
@@ -197,13 +196,10 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
               const jsi::Value& thisVal,
               const jsi::Value* args,
               size_t count) {
-            if (count == 0 || !args[0].isObject() ||
-                !args[0].asObject(rt).isHostObject<TimerHandle>(rt)) {
-              return jsi::Value::undefined();
+            if (count > 0 && args[0].isNumber()) {
+              auto handle = (TimerHandle)args[0].asNumber();
+              deleteReactNativeMicrotask(rt, handle);
             }
-            std::shared_ptr<TimerHandle> handle =
-                args[0].asObject(rt).asHostObject<TimerHandle>(rt);
-            deleteReactNativeMicrotask(rt, handle);
             return jsi::Value::undefined();
           }));
 
@@ -245,9 +241,7 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
               moreArgs.emplace_back(rt, args[extraArgNum]);
             }
 
-            auto handle =
-                createTimer(std::move(callback), std::move(moreArgs), delay);
-            return jsi::Object::createFromHostObject(rt, handle);
+            return createTimer(std::move(callback), std::move(moreArgs), delay);
           }));
 
   runtime.global().setProperty(
@@ -262,13 +256,10 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
               const jsi::Value& thisVal,
               const jsi::Value* args,
               size_t count) {
-            if (count == 0 || !args[0].isObject() ||
-                !args[0].asObject(rt).isHostObject<TimerHandle>(rt)) {
-              return jsi::Value::undefined();
+            if (count > 0 && args[0].isNumber()) {
+              auto handle = (TimerHandle)args[0].asNumber();
+              deleteTimer(rt, handle);
             }
-            std::shared_ptr<TimerHandle> host =
-                args[0].asObject(rt).asHostObject<TimerHandle>(rt);
-            deleteTimer(rt, host);
             return jsi::Value::undefined();
           }));
 
@@ -284,10 +275,10 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
               const jsi::Value& thisVal,
               const jsi::Value* args,
               size_t count) {
-            if (count < 2) {
+            if (count == 0) {
               throw jsi::JSError(
                   rt,
-                  "setInterval must be called with at least two arguments (the function to call and the delay).");
+                  "setInterval must be called with at least one argument (the function to call).");
             }
 
             if (!args[0].isObject() || !args[0].asObject(rt).isFunction(rt)) {
@@ -295,12 +286,8 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
                   rt, "The first argument to setInterval must be a function.");
             }
             auto callback = args[0].getObject(rt).getFunction(rt);
-
-            if (!args[1].isNumber()) {
-              throw jsi::JSError(
-                  rt, "The second argument to setInterval must be a number.");
-            }
-            auto delay = args[1].getNumber();
+            auto delay =
+                count > 1 && args[1].isNumber() ? args[1].getNumber() : 0;
 
             // Package up the remaining argument values into one place.
             std::vector<jsi::Value> moreArgs;
@@ -308,9 +295,8 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
               moreArgs.emplace_back(rt, args[extraArgNum]);
             }
 
-            auto handle = createRecurringTimer(
+            return createRecurringTimer(
                 std::move(callback), std::move(moreArgs), delay);
-            return jsi::Object::createFromHostObject(rt, handle);
           }));
 
   runtime.global().setProperty(
@@ -325,13 +311,10 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
               const jsi::Value& thisVal,
               const jsi::Value* args,
               size_t count) {
-            if (count == 0 || !args[0].isObject() ||
-                !args[0].asObject(rt).isHostObject<TimerHandle>(rt)) {
-              return jsi::Value::undefined();
+            if (count > 0 && args[0].isNumber()) {
+              auto handle = (TimerHandle)args[0].asNumber();
+              deleteRecurringTimer(rt, handle);
             }
-            std::shared_ptr<TimerHandle> host =
-                args[0].asObject(rt).asHostObject<TimerHandle>(rt);
-            deleteRecurringTimer(rt, host);
             return jsi::Value::undefined();
           }));
 
@@ -359,12 +342,11 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
                   "The first argument to requestAnimationFrame must be a function.");
             }
 
-            using CallbackContainer = std::tuple<jsi::Function>;
             auto callback = jsi::Function::createFromHostFunction(
                 rt,
                 jsi::PropNameID::forAscii(rt, "RN$rafFn"),
                 0,
-                [callbackContainer = std::make_shared<CallbackContainer>(
+                [callbackContainer = std::make_shared<jsi::Function>(
                      args[0].getObject(rt).getFunction(rt))](
                     jsi::Runtime& rt,
                     const jsi::Value& thisVal,
@@ -374,19 +356,16 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
                       rt.global().getPropertyAsObject(rt, "performance");
                   auto nowFn = performance.getPropertyAsFunction(rt, "now");
                   auto now = nowFn.callWithThis(rt, performance, {});
-
-                  return std::get<0>(*callbackContainer)
-                      .call(rt, {std::move(now)});
+                  return callbackContainer->call(rt, {std::move(now)});
                 });
 
             // The current implementation of requestAnimationFrame is the same
             // as setTimeout(0). This isn't exactly how requestAnimationFrame
             // is supposed to work on web, and may change in the future.
-            auto handle = createTimer(
+            return createTimer(
                 std::move(callback),
                 std::vector<jsi::Value>(),
                 /* delay */ 0);
-            return jsi::Object::createFromHostObject(rt, handle);
           }));
 
   runtime.global().setProperty(
@@ -401,13 +380,10 @@ void TimerManager::attachGlobals(jsi::Runtime& runtime) {
               const jsi::Value& thisVal,
               const jsi::Value* args,
               size_t count) {
-            if (count == 0 || !args[0].isObject() ||
-                !args[0].asObject(rt).isHostObject<TimerHandle>(rt)) {
-              return jsi::Value::undefined();
+            if (count > 0 && args[0].isNumber()) {
+              auto handle = (TimerHandle)args[0].asNumber();
+              deleteTimer(rt, handle);
             }
-            std::shared_ptr<TimerHandle> host =
-                args[0].asObject(rt).asHostObject<TimerHandle>(rt);
-            deleteTimer(rt, host);
             return jsi::Value::undefined();
           }));
 }

package/ReactCommon/react/runtime/TimerManager.h

@@ -16,31 +16,12 @@
 
 namespace facebook::react {
 
-/*
- * A HostObject subclass representing the result of a setTimeout call.
- * Can be used as an argument to clearTimeout.
- */
-class TimerHandle : public jsi::HostObject {
- public:
-  explicit TimerHandle(uint32_t index) : index_(index) {}
-
-  uint32_t index() const {
-    return index_;
-  }
-
-  ~TimerHandle() override = default;
-
- private:
-  // Index in the timeouts_ map of the owning SetTimeoutQueue.
-  uint32_t index_;
-};
+using TimerHandle = int;
 
 /*
  * Wraps a jsi::Function to make it copyable so we can pass it into a lambda.
  */
 struct TimerCallback {
-  TimerCallback(TimerCallback&&) = default;
-
   TimerCallback(
       jsi::Function callback,
       std::vector<jsi::Value> args,
@@ -67,49 +48,45 @@ class TimerManager {
 
   void callReactNativeMicrotasks(jsi::Runtime& runtime);
 
-  void callTimer(uint32_t);
+  void callTimer(TimerHandle handle);
 
   void attachGlobals(jsi::Runtime& runtime);
 
  private:
-  std::shared_ptr<TimerHandle> createReactNativeMicrotask(
+  TimerHandle createReactNativeMicrotask(
       jsi::Function&& callback,
       std::vector<jsi::Value>&& args);
 
-  void deleteReactNativeMicrotask(
-      jsi::Runtime& runtime,
-      std::shared_ptr<TimerHandle> handle);
+  void deleteReactNativeMicrotask(jsi::Runtime& runtime, TimerHandle handle);
 
-  std::shared_ptr<TimerHandle> createTimer(
+  TimerHandle createTimer(
       jsi::Function&& callback,
       std::vector<jsi::Value>&& args,
       double delay);
 
-  void deleteTimer(jsi::Runtime& runtime, std::shared_ptr<TimerHandle> handle);
+  void deleteTimer(jsi::Runtime& runtime, TimerHandle handle);
 
-  std::shared_ptr<TimerHandle> createRecurringTimer(
+  TimerHandle createRecurringTimer(
       jsi::Function&& callback,
       std::vector<jsi::Value>&& args,
       double delay);
 
-  void deleteRecurringTimer(
-      jsi::Runtime& runtime,
-      std::shared_ptr<TimerHandle> handle);
+  void deleteRecurringTimer(jsi::Runtime& runtime, TimerHandle handle);
 
   RuntimeExecutor runtimeExecutor_;
   std::unique_ptr<PlatformTimerRegistry> platformTimerRegistry_;
 
   // A map (id => callback func) of the currently active JS timers
-  std::unordered_map<uint32_t, std::shared_ptr<TimerCallback>> timers_;
+  std::unordered_map<TimerHandle, TimerCallback> timers_;
 
   // Each timeout that is registered on this queue gets a sequential id.  This
   // is the global count from which those are assigned.
-  uint32_t timerIndex_{0};
+  TimerHandle timerIndex_{0};
 
   // The React Native microtask queue is used to back public APIs including
   // `queueMicrotask`, `clearImmediate`, and `setImmediate` (which is used by
   // the Promise polyfill) when the JSVM microtask mechanism is not used.
-  std::vector<uint32_t> reactNativeMicrotasksQueue_;
+  std::vector<TimerHandle> reactNativeMicrotasksQueue_;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/runtime/hermes/HermesInstance.cpp

@@ -7,7 +7,7 @@
 
 #include "HermesInstance.h"
 
-#include <hermes/inspector-modern/chrome/HermesRuntimeAgentDelegate.h>
+#include <hermes/inspector-modern/chrome/HermesRuntimeTargetDelegate.h>
 #include <jsi/jsilib.h>
 #include <jsinspector-modern/InspectorFlags.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
@@ -94,49 +94,25 @@ class DecoratedRuntime : public jsi::RuntimeDecorator<jsi::Runtime> {
 
 class HermesJSRuntime : public JSRuntime {
  public:
-  HermesJSRuntime(
-      std::unique_ptr<HermesRuntime> runtime,
-      std::shared_ptr<MessageQueueThread> msgQueueThread)
-      : runtime_(std::move(runtime)),
-        msgQueueThread_(std::move(msgQueueThread)) {}
+  HermesJSRuntime(std::unique_ptr<HermesRuntime> runtime)
+      : runtime_(std::move(runtime)) {}
 
   jsi::Runtime& getRuntime() noexcept override {
     return *runtime_;
   }
 
-  std::unique_ptr<jsinspector_modern::RuntimeAgentDelegate> createAgentDelegate(
-      jsinspector_modern::FrontendChannel frontendChannel,
-      jsinspector_modern::SessionState& sessionState,
-      std::unique_ptr<jsinspector_modern::RuntimeAgentDelegate::ExportedState>
-          previouslyExportedState,
-      const jsinspector_modern::ExecutionContextDescription&
-          executionContextDescription) override {
-    return std::unique_ptr<jsinspector_modern::RuntimeAgentDelegate>(
-        new jsinspector_modern::HermesRuntimeAgentDelegate(
-            frontendChannel,
-            sessionState,
-            std::move(previouslyExportedState),
-            executionContextDescription,
-            runtime_,
-            [msgQueueThreadWeak = std::weak_ptr(msgQueueThread_),
-             runtimeWeak = std::weak_ptr(runtime_)](auto fn) {
-              auto msgQueueThread = msgQueueThreadWeak.lock();
-              if (!msgQueueThread) {
-                return;
-              }
-              msgQueueThread->runOnQueue([runtimeWeak, fn]() {
-                auto runtime = runtimeWeak.lock();
-                if (!runtime) {
-                  return;
-                }
-                fn(*runtime);
-              });
-            }));
+  jsinspector_modern::RuntimeTargetDelegate& getRuntimeTargetDelegate()
+      override {
+    if (!targetDelegate_) {
+      targetDelegate_.emplace(runtime_);
+    }
+    return *targetDelegate_;
   }
 
  private:
   std::shared_ptr<HermesRuntime> runtime_;
-  std::shared_ptr<MessageQueueThread> msgQueueThread_;
+  std::optional<jsinspector_modern::HermesRuntimeTargetDelegate>
+      targetDelegate_;
 };
 
 std::unique_ptr<JSRuntime> HermesInstance::createJSRuntime(
@@ -148,18 +124,11 @@ std::unique_ptr<JSRuntime> HermesInstance::createJSRuntime(
       ? reactNativeConfig->getInt64("ios_hermes:vm_experiment_flags")
       : 0;
 
-  int64_t heapSizeConfig = reactNativeConfig
-      ? reactNativeConfig->getInt64("ios_hermes:rn_heap_size_mb")
-      : 0;
-  // Default to 3GB if MobileConfigs is not available
-  auto heapSizeMB = heapSizeConfig > 0
-      ? static_cast<::hermes::vm::gcheapsize_t>(heapSizeConfig)
-      : 3072;
-
   ::hermes::vm::RuntimeConfig::Builder runtimeConfigBuilder =
       ::hermes::vm::RuntimeConfig::Builder()
           .withGCConfig(::hermes::vm::GCConfig::Builder()
-                            .withMaxHeapSize(heapSizeMB << 20)
+                            // Default to 3GB
+                            .withMaxHeapSize(3072 << 20)
                             .withName("RNBridgeless")
                             // For the next two arguments: avoid GC before TTI
                             // by initializing the runtime to allocate directly
@@ -181,16 +150,17 @@ std::unique_ptr<JSRuntime> HermesInstance::createJSRuntime(
 
 #ifdef HERMES_ENABLE_DEBUGGER
   auto& inspectorFlags = jsinspector_modern::InspectorFlags::getInstance();
-  if (!inspectorFlags.getEnableModernCDPRegistry()) {
+  if (!inspectorFlags.getFuseboxEnabled()) {
     std::unique_ptr<DecoratedRuntime> decoratedRuntime =
         std::make_unique<DecoratedRuntime>(
             std::move(hermesRuntime), msgQueueThread);
     return std::make_unique<JSIRuntimeHolder>(std::move(decoratedRuntime));
   }
+#else
+  (void)msgQueueThread;
 #endif
 
-  return std::make_unique<HermesJSRuntime>(
-      std::move(hermesRuntime), std::move(msgQueueThread));
+  return std::make_unique<HermesJSRuntime>(std::move(hermesRuntime));
 }
 
 } // namespace facebook::react

package/ReactCommon/react/runtime/nativeviewconfig/LegacyUIManagerConstantsProviderBinding.cpp

@@ -12,7 +12,7 @@ namespace facebook::react::LegacyUIManagerConstantsProviderBinding {
 void install(
     jsi::Runtime& runtime,
     const std::string& name,
-    std::function<jsi::Value()>&& provider) {
+    std::function<jsi::Value(jsi::Runtime&)>&& provider) {
   auto methodName = "RN$LegacyInterop_UIManager_" + name;
   auto hostFunction = [provider = std::move(provider)](
                           jsi::Runtime& runtime,
@@ -22,7 +22,7 @@ void install(
     if (count != 0) {
       throw new jsi::JSError(runtime, "0 arguments expected.");
     }
-    return provider();
+    return provider(runtime);
   };
 
   auto jsiFunction = jsi::Function::createFromHostFunction(
@@ -34,7 +34,7 @@ void install(
 void install(
     jsi::Runtime& runtime,
     const std::string& name,
-    std::function<jsi::Value(std::string)>&& provider) {
+    std::function<jsi::Value(jsi::Runtime&, const std::string&)>&& provider) {
   auto methodName = "RN$LegacyInterop_UIManager_" + name;
   auto hostFunction = [provider = std::move(provider)](
                           jsi::Runtime& runtime,
@@ -49,7 +49,7 @@ void install(
       throw new jsi::JSError(runtime, "First argument must be string.");
     }
 
-    return provider(args[0].asString(runtime).utf8(runtime));
+    return provider(runtime, args[0].asString(runtime).utf8(runtime));
   };
 
   auto jsiFunction = jsi::Function::createFromHostFunction(

package/ReactCommon/react/runtime/nativeviewconfig/LegacyUIManagerConstantsProviderBinding.h

@@ -11,8 +11,6 @@
 
 namespace facebook::react::LegacyUIManagerConstantsProviderBinding {
 
-using ProviderType = std::function<jsi::Value()>;
-
 /*
  * Installs RN$LegacyInterop_UIManager_getConstants binding into JavaScript
  * runtime. It is supposed to be used as a substitute to UIManager.getConstants
@@ -21,9 +19,9 @@ using ProviderType = std::function<jsi::Value()>;
 void install(
     jsi::Runtime& runtime,
     const std::string& name,
-    std::function<jsi::Value()>&& provider);
+    std::function<jsi::Value(jsi::Runtime&)>&& provider);
 void install(
     jsi::Runtime& runtime,
     const std::string& name,
-    std::function<jsi::Value(std::string)>&& provider);
+    std::function<jsi::Value(jsi::Runtime&, const std::string&)>&& provider);
 } // namespace facebook::react::LegacyUIManagerConstantsProviderBinding

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

@@ -42,7 +42,7 @@ Pod::Spec.new do |s|
   s.header_dir             = "ReactCommon"
   s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => header_search_paths,
                                 "USE_HEADERMAP" => "YES",
-                                "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+                                "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
                                 "GCC_WARN_PEDANTIC" => "YES" }
   s.compiler_flags       = folly_compiler_flags + ' ' + boost_compiler_flags
 
@@ -56,6 +56,7 @@ Pod::Spec.new do |s|
   s.dependency "React-cxxreact"
   s.dependency "React-callinvoker"
   s.dependency "React-runtimeexecutor"
+  s.dependency "React-runtimescheduler"
   s.dependency "React-utils"
   s.dependency "React-jsi"
   s.dependency "React-Core/Default"

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

@@ -77,12 +77,6 @@ typedef std::shared_ptr<facebook::react::JSRuntimeFactory> (^RCTHostJSEngineProv
 
 - (RCTFabricSurface *)createSurfaceWithModuleName:(NSString *)moduleName initialProperties:(NSDictionary *)properties;
 
-- (RCTSurfacePresenter *)getSurfacePresenter __attribute__((deprecated("Use `surfacePresenter` property instead.")));
-
-// Native module API
-
-- (RCTModuleRegistry *)getModuleRegistry __attribute__((deprecated("Use `moduleRegistry` property instead.")));
-
 @end
 
 NS_ASSUME_NONNULL_END