react-native 0.74.2 → 0.74.4

package/ReactCommon/jsc/JSCRuntime.cpp

@@ -13,8 +13,8 @@
 #include <atomic>
 #include <condition_variable>
 #include <cstdlib>
+#include <deque>
 #include <mutex>
-#include <queue>
 #include <sstream>
 #include <thread>
 
@@ -51,6 +51,12 @@ class JSCRuntime : public jsi::Runtime {
       const std::shared_ptr<const jsi::Buffer>& buffer,
       const std::string& sourceURL) override;
 
+  // If we use this interface to implement microtasks in the host we need to
+  // polyfill `Promise` to use these methods, because JSC doesn't currently
+  // support providing a custom queue for its built-in implementation.
+  // Not doing this would result in a non-compliant behavior, as microtasks
+  // wouldn't execute in the order in which they were queued.
+  void queueMicrotask(const jsi::Function& callback) override;
   bool drainMicrotasks(int maxMicrotasksHint = -1) override;
 
   jsi::Object global() override;
@@ -265,6 +271,7 @@ class JSCRuntime : public jsi::Runtime {
   std::atomic<bool> ctxInvalid_;
   std::string desc_;
   JSValueRef nativeStateSymbol_ = nullptr;
+  std::deque<jsi::Function> microtaskQueue_;
 #ifndef NDEBUG
   mutable std::atomic<intptr_t> objectCounter_;
   mutable std::atomic<intptr_t> symbolCounter_;
@@ -380,6 +387,10 @@ JSCRuntime::JSCRuntime(JSGlobalContextRef ctx)
 }
 
 JSCRuntime::~JSCRuntime() {
+  // We need to clear the microtask queue to remove all references to the
+  // callbacks, so objectCounter_ would be 0 below.
+  microtaskQueue_.clear();
+
   // On shutting down and cleaning up: when JSC is actually torn down,
   // it calls JSC::Heap::lastChanceToFinalize internally which
   // finalizes anything left over.  But at this point,
@@ -436,7 +447,24 @@ jsi::Value JSCRuntime::evaluateJavaScript(
   return createValue(res);
 }
 
-bool JSCRuntime::drainMicrotasks(int maxMicrotasksHint) {
+void JSCRuntime::queueMicrotask(const jsi::Function& callback) {
+  microtaskQueue_.emplace_back(
+      jsi::Value(*this, callback).asObject(*this).asFunction(*this));
+}
+
+bool JSCRuntime::drainMicrotasks(int /*maxMicrotasksHint*/) {
+  // Note that new jobs can be enqueued during the draining.
+  while (!microtaskQueue_.empty()) {
+    jsi::Function callback = std::move(microtaskQueue_.front());
+
+    // We need to pop before calling the callback because that might throw.
+    // When that happens, the host will call `drainMicrotasks` again to execute
+    // the remaining microtasks, and this one shouldn't run again.
+    microtaskQueue_.pop_front();
+
+    callback.call(*this);
+  }
+
   return true;
 }
 

package/ReactCommon/jserrorhandler/React-jserrorhandler.podspec

@@ -36,7 +36,7 @@ Pod::Spec.new do |s|
   s.source_files           = "JsErrorHandler.{cpp,h}"
   s.pod_target_xcconfig = {
     "USE_HEADERMAP" => "YES",
-    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20"
+    "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard()
   }
   s.compiler_flags         = folly_compiler_flags + ' ' + boost_compiler_flags
 

package/ReactCommon/jsi/jsi/decorator.h

@@ -126,6 +126,9 @@ class RuntimeDecorator : public Base, private jsi::Instrumentation {
       const std::shared_ptr<const PreparedJavaScript>& js) override {
     return plain().evaluatePreparedJavaScript(js);
   }
+  void queueMicrotask(const jsi::Function& callback) override {
+    return plain().queueMicrotask(callback);
+  }
   bool drainMicrotasks(int maxMicrotasksHint) override {
     return plain().drainMicrotasks(maxMicrotasksHint);
   }
@@ -544,6 +547,10 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
     Around around{with_};
     return RD::evaluatePreparedJavaScript(js);
   }
+  void queueMicrotask(const Function& callback) override {
+    Around around{with_};
+    RD::queueMicrotask(callback);
+  }
   bool drainMicrotasks(int maxMicrotasksHint) override {
     Around around{with_};
     return RD::drainMicrotasks(maxMicrotasksHint);

package/ReactCommon/jsi/jsi/jsi.h

@@ -209,6 +209,13 @@ class JSI_EXPORT Runtime {
   virtual Value evaluatePreparedJavaScript(
       const std::shared_ptr<const PreparedJavaScript>& js) = 0;
 
+  /// Queues a microtask in the JavaScript VM internal Microtask (a.k.a. Job in
+  /// ECMA262) queue, to be executed when the host drains microtasks in
+  /// its event loop implementation.
+  ///
+  /// \param callback a function to be executed as a microtask.
+  virtual void queueMicrotask(const jsi::Function& callback) = 0;
+
   /// Drain the JavaScript VM internal Microtask (a.k.a. Job in ECMA262) queue.
   ///
   /// \param maxMicrotasksHint a hint to tell an implementation that it should

package/ReactCommon/jsiexecutor/React-jsiexecutor.podspec

@@ -33,7 +33,7 @@ Pod::Spec.new do |s|
   s.source_files         = "jsireact/*.{cpp,h}"
   s.compiler_flags         = folly_compiler_flags + ' ' + boost_compiler_flags
   s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/RCT-Folly\" \"$(PODS_ROOT)/DoubleConversion\" \"$(PODS_ROOT)/fmt/include\"",
-                               "CLANG_CXX_LANGUAGE_STANDARD" => "c++20" }
+                               "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard() }
   s.header_dir             = "jsireact"
 
   s.dependency "React-cxxreact", version

package/ReactCommon/jsinspector-modern/React-jsinspector.podspec

@@ -38,7 +38,7 @@ Pod::Spec.new do |s|
   s.compiler_flags         = folly_compiler_flags
   s.pod_target_xcconfig    = {
                                "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/..\" \"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/RCT-Folly\" \"$(PODS_ROOT)/DoubleConversion\" \"$(PODS_ROOT)/fmt/include\"",
-                               "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+                               "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
                                "DEFINES_MODULE" => "YES"
   }.merge!(use_frameworks ? {
     "PUBLIC_HEADERS_FOLDER_PATH" => "#{module_name}.framework/Headers/#{header_dir}"

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

@@ -27,7 +27,7 @@ Pod::Spec.new do |s|
   s.source                 = source
   s.source_files           = "**/*.{cpp,h}"
   s.header_dir             = "react/debug"
-  s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+  s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
                                "DEFINES_MODULE" => "YES" }
 
   if ENV['USE_FRAMEWORKS']

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

@@ -33,7 +33,7 @@ Pod::Spec.new do |s|
   s.source                 = source
   s.source_files           = "*.{cpp,h}"
   s.header_dir             = "react/featureflags"
-  s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+  s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
                                "HEADER_SEARCH_PATHS" => header_search_paths.join(' '),
                                "DEFINES_MODULE" => "YES" }
 

package/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.cpp

@@ -86,6 +86,38 @@ struct JNIArgs {
   std::vector<jobject> globalRefs_;
 };
 
+jsi::Value createJSRuntimeError(
+    jsi::Runtime& runtime,
+    const std::string& message) {
+  return runtime.global()
+      .getPropertyAsFunction(runtime, "Error")
+      .call(runtime, message);
+}
+
+jsi::Value createRejectionError(jsi::Runtime& rt, const folly::dynamic& args) {
+  react_native_assert(
+      args.size() == 1 && "promise reject should has only one argument");
+
+  auto value = jsi::valueFromDynamic(rt, args[0]);
+  react_native_assert(value.isObject() && "promise reject should return a map");
+
+  const jsi::Object& valueAsObject = value.asObject(rt);
+
+  auto messageProperty = valueAsObject.getProperty(rt, "message");
+  auto jsError =
+      createJSRuntimeError(rt, messageProperty.asString(rt).utf8(rt));
+
+  auto jsErrorAsObject = jsError.asObject(rt);
+  auto propertyNames = valueAsObject.getPropertyNames(rt);
+  for (size_t i = 0; i < propertyNames.size(rt); ++i) {
+    auto propertyName = jsi::PropNameID::forString(
+        rt, propertyNames.getValueAtIndex(rt, i).asString(rt));
+    jsErrorAsObject.setProperty(
+        rt, propertyName, valueAsObject.getProperty(rt, propertyName));
+  }
+  return jsError;
+}
+
 auto createJavaCallback(
     jsi::Runtime& rt,
     jsi::Function&& function,
@@ -98,7 +130,6 @@ auto createJavaCallback(
           LOG(FATAL) << "Callback arg cannot be called more than once";
           return;
         }
-
         callback->call([args = std::move(args)](
                            jsi::Runtime& rt, jsi::Function& jsFunction) {
           std::vector<jsi::Value> jsArgs;
@@ -112,6 +143,26 @@ auto createJavaCallback(
       });
 }
 
+auto createJavaRejectCallback(
+    jsi::Runtime& rt,
+    jsi::Function&& function,
+    std::shared_ptr<CallInvoker> jsInvoker) {
+  std::optional<AsyncCallback<>> callback(
+      {rt, std::move(function), std::move(jsInvoker)});
+  return JCxxCallbackImpl::newObjectCxxArgs(
+      [callback = std::move(callback)](folly::dynamic args) mutable {
+        if (!callback) {
+          LOG(FATAL) << "Callback arg cannot be called more than once";
+          return;
+        }
+        callback->call([args = std::move(args)](
+                           jsi::Runtime& rt, jsi::Function& jsFunction) {
+          jsFunction.call(rt, createRejectionError(rt, args));
+        });
+        callback = std::nullopt;
+      });
+}
+
 struct JPromiseImpl : public jni::JavaClass<JPromiseImpl> {
   constexpr static auto kJavaDescriptor =
       "Lcom/facebook/react/bridge/PromiseImpl;";
@@ -407,14 +458,6 @@ jsi::Value convertFromJMapToValue(JNIEnv* env, jsi::Runtime& rt, jobject arg) {
   return jsi::valueFromDynamic(rt, result->cthis()->consume());
 }
 
-jsi::Value createJSRuntimeError(
-    jsi::Runtime& runtime,
-    const std::string& message) {
-  return runtime.global()
-      .getPropertyAsFunction(runtime, "Error")
-      .call(runtime, message);
-}
-
 /**
  * Creates JSError with current JS runtime stack and Throwable stack trace.
  */
@@ -855,7 +898,7 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
                     runtime,
                     args[0].getObject(runtime).getFunction(runtime),
                     jsInvoker_);
-                auto reject = createJavaCallback(
+                auto reject = createJavaRejectCallback(
                     runtime,
                     args[1].getObject(runtime).getFunction(runtime),
                     jsInvoker_);

package/ReactCommon/react/nativemodule/core/platform/ios/React-NativeModulesApple.podspec

@@ -36,7 +36,7 @@ Pod::Spec.new do |s|
     s.compiler_flags         = folly_compiler_flags + ' ' + boost_compiler_flags
     s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/RCT-Folly\" \"$(PODS_ROOT)/DoubleConversion\" \"$(PODS_ROOT)/fmt/include\" \"$(PODS_ROOT)/Headers/Private/React-Core\"",
                                 "USE_HEADERMAP" => "YES",
-                                "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+                                "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
                                 "GCC_WARN_PEDANTIC" => "YES" }
     if ENV['USE_FRAMEWORKS']
         s.header_mappings_dir     = './'

package/ReactCommon/react/nativemodule/samples/ReactCommon-Samples.podspec

@@ -47,7 +47,7 @@ Pod::Spec.new do |s|
   s.compiler_flags         = folly_compiler_flags + ' ' + boost_compiler_flags
   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" }
   if ENV['USE_FRAMEWORKS']
     s.header_mappings_dir     = './'

package/ReactCommon/react/renderer/components/legacyviewmanagerinterop/LegacyViewManagerInteropComponentDescriptor.mm

@@ -125,9 +125,10 @@ static const std::shared_ptr<void> constructCoordinator(
     bridgeModuleDecorator = unwrapManagedObject(optionalModuleDecorator.value());
   }
 
-  RCTComponentData *componentData = [[RCTComponentData alloc] initWithManagerClass:viewManagerClass
-                                                                            bridge:bridge
-                                                                   eventDispatcher:eventDispatcher];
+  RCTComponentData *componentData =
+      [[RCTComponentData alloc] initWithManagerClass:viewManagerClass
+                                              bridge:bridge != nil ? bridge : (RCTBridge *)bridgeProxy
+                                     eventDispatcher:eventDispatcher];
   return wrapManagedObject([[RCTLegacyViewManagerInteropCoordinator alloc]
       initWithComponentData:componentData
                      bridge:bridge

package/ReactCommon/react/renderer/debug/React-rendererdebug.podspec

@@ -45,7 +45,7 @@ Pod::Spec.new do |s|
   s.header_dir             = "react/renderer/debug"
   s.exclude_files          = "tests"
   s.pod_target_xcconfig    = {
-    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
     "HEADER_SEARCH_PATHS" => header_search_paths.join(' '),
     "DEFINES_MODULE" => "YES"
   }

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

@@ -57,7 +57,7 @@ Pod::Spec.new do |s|
   s.pod_target_xcconfig  = { "USE_HEADERMAP" => "NO",
                              "HEADER_SEARCH_PATHS" => header_search_paths.join(" "),
                              "DEFINES_MODULE" => "YES",
-                             "CLANG_CXX_LANGUAGE_STANDARD" => "c++20" }
+                             "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard() }
 
   s.dependency "glog"
   s.dependency "RCT-Folly/Fabric", folly_version

package/ReactCommon/react/renderer/imagemanager/platform/ios/React-ImageManager.podspec

@@ -50,7 +50,7 @@ Pod::Spec.new do |s|
   s.pod_target_xcconfig  = {
     "USE_HEADERMAP" => "NO",
     "HEADER_SEARCH_PATHS" => header_search_paths,
-    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
     "DEFINES_MODULE" => "YES",
   }
 

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

@@ -43,7 +43,7 @@ Pod::Spec.new do |s|
   s.header_dir             = "react/renderer/runtimescheduler"
   s.exclude_files          = "tests"
   s.pod_target_xcconfig    = {
-    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
     "HEADER_SEARCH_PATHS" => header_search_paths.join(' ')}
 
   if ENV['USE_FRAMEWORKS']

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

@@ -13,7 +13,6 @@
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/debug/SystraceSection.h>
 #include <utility>
-#include "ErrorUtils.h"
 
 namespace facebook::react {
 

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

@@ -8,9 +8,9 @@
 #include "RuntimeScheduler_Legacy.h"
 #include "SchedulerPriorityUtils.h"
 
+#include <cxxreact/ErrorUtils.h>
 #include <react/renderer/debug/SystraceSection.h>
 #include <utility>
-#include "ErrorUtils.h"
 
 namespace facebook::react {
 
@@ -136,7 +136,7 @@ void RuntimeScheduler_Legacy::callExpiredTasks(jsi::Runtime& runtime) {
       executeTask(runtime, topPriorityTask, didUserCallbackTimeout);
     }
   } catch (jsi::JSError& error) {
-    handleFatalError(runtime, error);
+    handleJSError(runtime, error, true);
   }
 
   currentPriority_ = previousPriority;
@@ -182,7 +182,7 @@ void RuntimeScheduler_Legacy::startWorkLoop(jsi::Runtime& runtime) {
       executeTask(runtime, topPriorityTask, didUserCallbackTimeout);
     }
   } catch (jsi::JSError& error) {
-    handleFatalError(runtime, error);
+    handleJSError(runtime, error, true);
   }
 
   currentPriority_ = previousPriority;

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

@@ -12,7 +12,6 @@
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/debug/SystraceSection.h>
 #include <utility>
-#include "ErrorUtils.h"
 
 namespace facebook::react {
 
@@ -104,7 +103,7 @@ bool RuntimeScheduler_Modern::getShouldYield() const noexcept {
   std::shared_lock lock(schedulingMutex_);
 
   return syncTaskRequests_ > 0 ||
-      (!taskQueue_.empty() && taskQueue_.top() != currentTask_);
+      (!taskQueue_.empty() && taskQueue_.top().get() != currentTask_);
 }
 
 bool RuntimeScheduler_Modern::getIsSynchronous() const noexcept {
@@ -144,9 +143,8 @@ void RuntimeScheduler_Modern::executeNowOnTheSameThread(
         auto priority = SchedulerPriority::ImmediatePriority;
         auto expirationTime =
             currentTime + timeoutForSchedulerPriority(priority);
-        auto task = std::make_shared<Task>(
-            priority, std::move(callback), expirationTime);
 
+        auto task = Task{priority, std::move(callback), expirationTime};
         executeTask(runtime, task, currentTime);
 
         isSynchronous_ = false;
@@ -231,21 +229,17 @@ void RuntimeScheduler_Modern::startWorkLoop(
 
   auto previousPriority = currentPriority_;
 
-  try {
-    while (syncTaskRequests_ == 0) {
-      auto currentTime = now_();
-      auto topPriorityTask = selectTask(currentTime, onlyExpired);
+  while (syncTaskRequests_ == 0) {
+    auto currentTime = now_();
+    auto topPriorityTask = selectTask(currentTime, onlyExpired);
 
-      if (!topPriorityTask) {
-        // No pending work to do.
-        // Events will restart the loop when necessary.
-        break;
-      }
-
-      executeTask(runtime, topPriorityTask, currentTime);
+    if (!topPriorityTask) {
+      // No pending work to do.
+      // Events will restart the loop when necessary.
+      break;
     }
-  } catch (jsi::JSError& error) {
-    handleFatalError(runtime, error);
+
+    executeTask(runtime, *topPriorityTask, currentTime);
   }
 
   currentPriority_ = previousPriority;
@@ -280,19 +274,19 @@ std::shared_ptr<Task> RuntimeScheduler_Modern::selectTask(
 
 void RuntimeScheduler_Modern::executeTask(
     jsi::Runtime& runtime,
-    const std::shared_ptr<Task>& task,
+    Task& task,
     RuntimeSchedulerTimePoint currentTime) {
-  auto didUserCallbackTimeout = task->expirationTime <= currentTime;
+  auto didUserCallbackTimeout = task.expirationTime <= currentTime;
 
   SystraceSection s(
       "RuntimeScheduler::executeTask",
       "priority",
-      serialize(task->priority),
+      serialize(task.priority),
       "didUserCallbackTimeout",
       didUserCallbackTimeout);
 
-  currentTask_ = task;
-  currentPriority_ = task->priority;
+  currentTask_ = &task;
+  currentPriority_ = task.priority;
 
   executeMacrotask(runtime, task, didUserCallbackTimeout);
 
@@ -305,6 +299,8 @@ void RuntimeScheduler_Modern::executeTask(
     // "Update the rendering" step.
     updateRendering();
   }
+
+  currentTask_ = nullptr;
 }
 
 /**
@@ -326,16 +322,20 @@ void RuntimeScheduler_Modern::updateRendering() {
 
 void RuntimeScheduler_Modern::executeMacrotask(
     jsi::Runtime& runtime,
-    std::shared_ptr<Task> task,
+    Task& task,
     bool didUserCallbackTimeout) const {
   SystraceSection s("RuntimeScheduler::executeMacrotask");
 
-  auto result = task->execute(runtime, didUserCallbackTimeout);
+  try {
+    auto result = task.execute(runtime, didUserCallbackTimeout);
 
-  if (result.isObject() && result.getObject(runtime).isFunction(runtime)) {
-    // If the task returned a continuation callback, we re-assign it to the task
-    // and keep the task in the queue.
-    task->callback = result.getObject(runtime).getFunction(runtime);
+    if (result.isObject() && result.getObject(runtime).isFunction(runtime)) {
+      // If the task returned a continuation callback, we re-assign it to the
+      // task and keep the task in the queue.
+      task.callback = result.getObject(runtime).getFunction(runtime);
+    }
+  } catch (jsi::JSError& error) {
+    handleJSError(runtime, error, true);
   }
 }
 

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

@@ -139,7 +139,7 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
       TaskPriorityComparer>
       taskQueue_;
 
-  std::shared_ptr<Task> currentTask_;
+  Task* currentTask_{};
 
   /**
    * This protects the access to `taskQueue_` and `isWorkLoopScheduled_`.
@@ -168,12 +168,12 @@ class RuntimeScheduler_Modern final : public RuntimeSchedulerBase {
    */
   void executeTask(
       jsi::Runtime& runtime,
-      const std::shared_ptr<Task>& task,
+      Task& task,
       RuntimeSchedulerTimePoint currentTime);
 
   void executeMacrotask(
       jsi::Runtime& runtime,
-      std::shared_ptr<Task> task,
+      Task& task,
       bool didUserCallbackTimeout) const;
 
   void updateRendering();

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

@@ -32,20 +32,22 @@ jsi::Value Task::execute(jsi::Runtime& runtime, bool didUserCallbackTimeout) {
     return result;
   }
 
-  auto& cbVal = callback.value();
+  // We get the value of the callback and reset it immediately to avoid it being
+  // called more than once (including when the callback throws).
+  auto originalCallback = std::move(*callback);
+  callback.reset();
 
-  if (cbVal.index() == 0) {
+  if (originalCallback.index() == 0) {
     // Callback in JavaScript is expecting a single bool parameter.
     // React team plans to remove it in the future when a scheduler bug on web
     // is resolved.
-    result =
-        std::get<jsi::Function>(cbVal).call(runtime, {didUserCallbackTimeout});
+    result = std::get<jsi::Function>(originalCallback)
+                 .call(runtime, {didUserCallbackTimeout});
   } else {
     // Calling a raw callback
-    std::get<RawCallback>(cbVal)(runtime);
+    std::get<RawCallback>(originalCallback)(runtime);
   }
-  // Destroying callback to prevent calling it twice.
-  callback.reset();
+
   return result;
 }
 

package/ReactCommon/react/renderer/runtimescheduler/tests/RuntimeSchedulerTest.cpp

@@ -1021,6 +1021,52 @@ TEST_P(RuntimeSchedulerTest, modernTwoThreadsRequestAccessToTheRuntime) {
   EXPECT_EQ(stubQueue_->size(), 0);
 }
 
+TEST_P(RuntimeSchedulerTest, errorInTaskShouldNotStopMicrotasks) {
+  // Only for modern runtime scheduler
+  if (!GetParam()) {
+    return;
+  }
+
+  auto microtaskRan = false;
+  auto taskRan = false;
+
+  auto callback = createHostFunctionFromLambda([&](bool /* unused */) {
+    taskRan = true;
+
+    auto microtaskCallback = jsi::Function::createFromHostFunction(
+        *runtime_,
+        jsi::PropNameID::forUtf8(*runtime_, "microtask1"),
+        3,
+        [&](jsi::Runtime& /*unused*/,
+            const jsi::Value& /*unused*/,
+            const jsi::Value* /*arguments*/,
+            size_t /*unused*/) -> jsi::Value {
+          microtaskRan = true;
+          return jsi::Value::undefined();
+        });
+
+    runtime_->queueMicrotask(microtaskCallback);
+
+    throw jsi::JSError(*runtime_, "Test error");
+
+    return jsi::Value::undefined();
+  });
+
+  runtimeScheduler_->scheduleTask(
+      SchedulerPriority::NormalPriority, std::move(callback));
+
+  EXPECT_EQ(taskRan, false);
+  EXPECT_EQ(microtaskRan, false);
+  EXPECT_EQ(stubQueue_->size(), 1);
+
+  stubQueue_->tick();
+
+  EXPECT_EQ(taskRan, 1);
+  EXPECT_EQ(microtaskRan, 1);
+  EXPECT_EQ(stubQueue_->size(), 0);
+  EXPECT_EQ(stubErrorUtils_->getReportFatalCallCount(), 1);
+}
+
 INSTANTIATE_TEST_SUITE_P(
     UseModernRuntimeScheduler,
     RuntimeSchedulerTest,

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

@@ -37,7 +37,7 @@ Pod::Spec.new do |s|
   s.header_dir             = "react/runtime"
   s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/Headers/Private/React-Core\" \"${PODS_TARGET_SRCROOT}/../..\"",
                                 "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
 

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

@@ -35,7 +35,7 @@ Pod::Spec.new do |s|
   s.header_dir             = "react/runtime/hermes"
   s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"${PODS_TARGET_SRCROOT}/../..\" \"${PODS_TARGET_SRCROOT}/../../hermes/executor\" \"$(PODS_ROOT)/boost\"",
                                 "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
 

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
 

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

@@ -39,7 +39,7 @@ Pod::Spec.new do |s|
   s.compiler_flags         = folly_compiler_flags
   s.header_dir             = "react/utils"
   s.exclude_files          = "tests"
-  s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+  s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
                                "HEADER_SEARCH_PATHS" => header_search_paths.join(' '),
                                "DEFINES_MODULE" => "YES" }
 

package/ReactCommon/reactperflogger/React-perflogger.podspec

@@ -32,5 +32,5 @@ Pod::Spec.new do |s|
   s.source                 = source
   s.source_files           = "**/*.{cpp,h}"
   s.header_dir             = "reactperflogger"
-  s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => "c++20" }
+  s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard() }
 end