react-native 0.71.6 → 0.72.0-rc.1

package/ReactCommon/react/renderer/imagemanager/primitives.h

@@ -10,7 +10,8 @@
 #include <string>
 #include <vector>
 
-#include <react/renderer/graphics/Geometry.h>
+#include <react/renderer/graphics/Float.h>
+#include <react/renderer/graphics/Size.h>
 
 namespace facebook {
 namespace react {

package/ReactCommon/react/renderer/mapbuffer/MapBuffer.h

@@ -111,10 +111,12 @@ class MapBuffer {
 
   MapBuffer(MapBuffer const &buffer) = delete;
 
-  MapBuffer &operator=(MapBuffer other) = delete;
+  MapBuffer &operator=(const MapBuffer &other) = delete;
 
   MapBuffer(MapBuffer &&buffer) = default;
 
+  MapBuffer &operator=(MapBuffer &&other) = default;
+
   int32_t getInt(MapBuffer::Key key) const;
 
   bool getBool(MapBuffer::Key key) const;
@@ -136,7 +138,7 @@ class MapBuffer {
 
  private:
   // Buffer and its size
-  std::vector<uint8_t> const bytes_;
+  std::vector<uint8_t> bytes_;
 
   // amount of items in the MapBuffer
   uint16_t count_ = 0;

package/ReactCommon/react/renderer/mounting/Differentiator.cpp

@@ -503,7 +503,7 @@ static void updateMatchedPairSubtrees(
  *
  * Here we have (and need) knowledge of whether a node was found during
  * in-order traversal, or out-of-order via a map lookup. Nodes are only REMOVEd
- * or INSERTed when they are encountered via in-order-traversal, to ensure
+ * or INSERTTed when they are encountered via in-order-traversal, to ensure
  * correct ordering of INSERT and REMOVE mutations.
  */
 static void updateMatchedPair(

package/ReactCommon/react/renderer/mounting/MountingCoordinator.cpp

@@ -33,7 +33,7 @@ SurfaceId MountingCoordinator::getSurfaceId() const {
   return surfaceId_;
 }
 
-void MountingCoordinator::push(ShadowTreeRevision const &revision) const {
+void MountingCoordinator::push(ShadowTreeRevision revision) const {
   {
     std::lock_guard<std::mutex> lock(mutex_);
 
@@ -41,7 +41,7 @@ void MountingCoordinator::push(ShadowTreeRevision const &revision) const {
         !lastRevision_.has_value() || revision.number != lastRevision_->number);
 
     if (!lastRevision_.has_value() || lastRevision_->number < revision.number) {
-      lastRevision_ = revision;
+      lastRevision_ = std::move(revision);
     }
   }
 

package/ReactCommon/react/renderer/mounting/MountingCoordinator.h

@@ -88,7 +88,7 @@ class MountingCoordinator final {
  private:
   friend class ShadowTree;
 
-  void push(ShadowTreeRevision const &revision) const;
+  void push(ShadowTreeRevision revision) const;
 
   /*
    * Revokes the last pushed `ShadowTreeRevision`.

package/ReactCommon/react/renderer/mounting/ShadowTree.cpp

@@ -269,7 +269,7 @@ void ShadowTree::setCommitMode(CommitMode commitMode) const {
   auto revision = ShadowTreeRevision{};
 
   {
-    std::unique_lock<butter::shared_mutex> lock(commitMutex_);
+    std::unique_lock lock(commitMutex_);
     if (commitMode_ == commitMode) {
       return;
     }
@@ -281,12 +281,12 @@ void ShadowTree::setCommitMode(CommitMode commitMode) const {
   // initial revision never contains any commits so mounting it here is
   // incorrect
   if (commitMode == CommitMode::Normal && revision.number != INITIAL_REVISION) {
-    mount(revision);
+    mount(revision, true);
   }
 }
 
 CommitMode ShadowTree::getCommitMode() const {
-  std::shared_lock<butter::shared_mutex> lock(commitMutex_);
+  std::shared_lock lock(commitMutex_);
   return commitMode_;
 }
 
@@ -329,7 +329,7 @@ CommitStatus ShadowTree::tryCommit(
 
   {
     // Reading `currentRevision_` in shared manner.
-    std::shared_lock<butter::shared_mutex> lock(commitMutex_);
+    std::shared_lock lock(commitMutex_);
     commitMode = commitMode_;
     oldRevision = currentRevision_;
   }
@@ -351,6 +351,10 @@ CommitStatus ShadowTree::tryCommit(
     }
   }
 
+  // Run commit hooks.
+  newRootShadowNode = delegate_.shadowTreeWillCommit(
+      *this, oldRootShadowNode, newRootShadowNode);
+
   // Layout nodes.
   std::vector<LayoutableShadowNode const *> affectedLayoutableNodes{};
   affectedLayoutableNodes.reserve(1024);
@@ -366,7 +370,7 @@ CommitStatus ShadowTree::tryCommit(
 
   {
     // Updating `currentRevision_` in unique manner if it hasn't changed.
-    std::unique_lock<butter::shared_mutex> lock(commitMutex_);
+    std::unique_lock lock(commitMutex_);
 
     if (currentRevision_.number != oldRevision.number) {
       return CommitStatus::Failed;
@@ -374,9 +378,6 @@ CommitStatus ShadowTree::tryCommit(
 
     auto newRevisionNumber = oldRevision.number + 1;
 
-    newRootShadowNode = delegate_.shadowTreeWillCommit(
-        *this, oldRootShadowNode, newRootShadowNode);
-
     if (!newRootShadowNode ||
         (commitOptions.shouldYield && commitOptions.shouldYield())) {
       return CommitStatus::Cancelled;
@@ -393,8 +394,8 @@ CommitStatus ShadowTree::tryCommit(
     telemetry.didCommit();
     telemetry.setRevisionNumber(static_cast<int>(newRevisionNumber));
 
-    newRevision =
-        ShadowTreeRevision{newRootShadowNode, newRevisionNumber, telemetry};
+    newRevision = ShadowTreeRevision{
+        std::move(newRootShadowNode), newRevisionNumber, telemetry};
 
     currentRevision_ = newRevision;
   }
@@ -402,20 +403,22 @@ CommitStatus ShadowTree::tryCommit(
   emitLayoutEvents(affectedLayoutableNodes);
 
   if (commitMode == CommitMode::Normal) {
-    mount(newRevision);
+    mount(std::move(newRevision), commitOptions.mountSynchronously);
   }
 
   return CommitStatus::Succeeded;
 }
 
 ShadowTreeRevision ShadowTree::getCurrentRevision() const {
-  std::shared_lock<butter::shared_mutex> lock(commitMutex_);
+  std::shared_lock lock(commitMutex_);
   return currentRevision_;
 }
 
-void ShadowTree::mount(ShadowTreeRevision const &revision) const {
-  mountingCoordinator_->push(revision);
-  delegate_.shadowTreeDidFinishTransaction(*this, mountingCoordinator_);
+void ShadowTree::mount(ShadowTreeRevision revision, bool mountSynchronously)
+    const {
+  mountingCoordinator_->push(std::move(revision));
+  delegate_.shadowTreeDidFinishTransaction(
+      mountingCoordinator_, mountSynchronously);
 }
 
 void ShadowTree::commitEmptyTree() const {
@@ -427,7 +430,8 @@ void ShadowTree::commitEmptyTree() const {
                 /* .props = */ ShadowNodeFragment::propsPlaceholder(),
                 /* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
             });
-      });
+      },
+      {/* default commit options */});
 }
 
 void ShadowTree::emitLayoutEvents(
@@ -457,7 +461,7 @@ void ShadowTree::emitLayoutEvents(
 }
 
 void ShadowTree::notifyDelegatesOfUpdates() const {
-  delegate_.shadowTreeDidFinishTransaction(*this, mountingCoordinator_);
+  delegate_.shadowTreeDidFinishTransaction(mountingCoordinator_, true);
 }
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/mounting/ShadowTree.h

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include <butter/mutex.h>
 #include <memory>
 
 #include <react/renderer/components/root/RootComponentDescriptor.h>
@@ -59,6 +58,13 @@ class ShadowTree final {
   struct CommitOptions {
     bool enableStateReconciliation{false};
 
+    // Indicates if mounting will be triggered synchronously and React will
+    // not get a chance to interrupt painting.
+    // This should be set to `false` when a commit is coming from React. It
+    // will then let React run layout effects and apply updates before paint.
+    // For all other commits, should be true.
+    bool mountSynchronously{true};
+
     // Called during `tryCommit` phase. Returning true indicates current commit
     // should yield to the next commit.
     std::function<bool()> shouldYield;
@@ -96,14 +102,14 @@ class ShadowTree final {
    */
   CommitStatus tryCommit(
       const ShadowTreeCommitTransaction &transaction,
-      const CommitOptions &commitOptions = {false}) const;
+      const CommitOptions &commitOptions) const;
 
   /*
    * Calls `tryCommit` in a loop until it finishes successfully.
    */
   CommitStatus commit(
       const ShadowTreeCommitTransaction &transaction,
-      const CommitOptions &commitOptions = {false}) const;
+      const CommitOptions &commitOptions) const;
 
   /*
    * Returns a `ShadowTreeRevision` representing the momentary state of
@@ -128,14 +134,14 @@ class ShadowTree final {
  private:
   constexpr static ShadowTreeRevision::Number INITIAL_REVISION{0};
 
-  void mount(ShadowTreeRevision const &revision) const;
+  void mount(ShadowTreeRevision revision, bool mountSynchronously) const;
 
   void emitLayoutEvents(
       std::vector<LayoutableShadowNode const *> &affectedLayoutableNodes) const;
 
   SurfaceId const surfaceId_;
   ShadowTreeDelegate const &delegate_;
-  mutable butter::shared_mutex commitMutex_;
+  mutable std::shared_mutex commitMutex_;
   mutable CommitMode commitMode_{
       CommitMode::Normal}; // Protected by `commitMutex_`.
   mutable ShadowTreeRevision currentRevision_; // Protected by `commitMutex_`.

package/ReactCommon/react/renderer/mounting/ShadowTreeDelegate.h

@@ -34,8 +34,8 @@ class ShadowTreeDelegate {
    * Called right after Shadow Tree commit a new state of the tree.
    */
   virtual void shadowTreeDidFinishTransaction(
-      ShadowTree const &shadowTree,
-      MountingCoordinator::Shared const &mountingCoordinator) const = 0;
+      MountingCoordinator::Shared mountingCoordinator,
+      bool mountSynchronously) const = 0;
 
   virtual ~ShadowTreeDelegate() noexcept = default;
 };

package/ReactCommon/react/renderer/mounting/ShadowTreeRegistry.cpp

@@ -17,14 +17,14 @@ ShadowTreeRegistry::~ShadowTreeRegistry() {
 }
 
 void ShadowTreeRegistry::add(std::unique_ptr<ShadowTree> &&shadowTree) const {
-  std::unique_lock<butter::shared_mutex> lock(mutex_);
+  std::unique_lock lock(mutex_);
 
   registry_.emplace(shadowTree->getSurfaceId(), std::move(shadowTree));
 }
 
 std::unique_ptr<ShadowTree> ShadowTreeRegistry::remove(
     SurfaceId surfaceId) const {
-  std::unique_lock<butter::shared_mutex> lock(mutex_);
+  std::unique_lock lock(mutex_);
 
   auto iterator = registry_.find(surfaceId);
   if (iterator == registry_.end()) {
@@ -39,7 +39,7 @@ std::unique_ptr<ShadowTree> ShadowTreeRegistry::remove(
 bool ShadowTreeRegistry::visit(
     SurfaceId surfaceId,
     std::function<void(const ShadowTree &shadowTree)> const &callback) const {
-  std::shared_lock<butter::shared_mutex> lock(mutex_);
+  std::shared_lock lock(mutex_);
 
   auto iterator = registry_.find(surfaceId);
 
@@ -52,10 +52,15 @@ bool ShadowTreeRegistry::visit(
 }
 
 void ShadowTreeRegistry::enumerate(
-    std::function<void(const ShadowTree &shadowTree)> const &callback) const {
-  std::shared_lock<butter::shared_mutex> lock(mutex_);
+    std::function<void(const ShadowTree &shadowTree, bool &stop)> const
+        &callback) const {
+  std::shared_lock lock(mutex_);
+  auto stop = false;
   for (auto const &pair : registry_) {
-    callback(*pair.second);
+    callback(*pair.second, stop);
+    if (stop) {
+      return;
+    }
   }
 }
 

package/ReactCommon/react/renderer/mounting/ShadowTreeRegistry.h

@@ -7,8 +7,9 @@
 
 #pragma once
 
+#include <shared_mutex>
+
 #include <butter/map.h>
-#include <butter/mutex.h>
 
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/mounting/ShadowTree.h>
@@ -54,13 +55,15 @@ class ShadowTreeRegistry final {
 
   /*
    * Enumerates all stored shadow trees.
+   * Set `stop` to `true` to interrupt the enumeration.
    * Can be called from any thread.
    */
   void enumerate(
-      std::function<void(const ShadowTree &shadowTree)> const &callback) const;
+      std::function<void(const ShadowTree &shadowTree, bool &stop)> const
+          &callback) const;
 
  private:
-  mutable butter::shared_mutex mutex_;
+  mutable std::shared_mutex mutex_;
   mutable butter::map<SurfaceId, std::unique_ptr<ShadowTree>>
       registry_; // Protected by `mutex_`.
 };

package/ReactCommon/react/renderer/mounting/ShadowView.cpp

@@ -9,6 +9,7 @@
 
 #include <react/renderer/core/LayoutMetrics.h>
 #include <react/renderer/core/LayoutableShadowNode.h>
+#include <react/renderer/core/TraitCast.h>
 
 namespace facebook::react {
 

package/ReactCommon/react/renderer/mounting/tests/ShadowTreeLifeCycleTest.cpp

@@ -332,7 +332,7 @@ static void testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
 using namespace facebook::react;
 
 TEST(
-    ShadowTreeLifecyleTest,
+    ShadowTreeLifecycleTest,
     stableBiggerTreeFewerIterationsOptimizedMovesFlattener) {
   testShadowNodeTreeLifeCycle(
       /* seed */ 0,
@@ -342,7 +342,7 @@ TEST(
 }
 
 TEST(
-    ShadowTreeLifecyleTest,
+    ShadowTreeLifecycleTest,
     stableBiggerTreeFewerIterationsOptimizedMovesFlattener2) {
   testShadowNodeTreeLifeCycle(
       /* seed */ 1,
@@ -352,7 +352,7 @@ TEST(
 }
 
 TEST(
-    ShadowTreeLifecyleTest,
+    ShadowTreeLifecycleTest,
     stableSmallerTreeMoreIterationsOptimizedMovesFlattener) {
   testShadowNodeTreeLifeCycle(
       /* seed */ 0,
@@ -362,7 +362,7 @@ TEST(
 }
 
 TEST(
-    ShadowTreeLifecyleTest,
+    ShadowTreeLifecycleTest,
     unstableSmallerTreeFewerIterationsExtensiveFlatteningUnflattening) {
   testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
       /* seed */ 1337,
@@ -372,7 +372,7 @@ TEST(
 }
 
 TEST(
-    ShadowTreeLifecyleTest,
+    ShadowTreeLifecycleTest,
     unstableBiggerTreeFewerIterationsExtensiveFlatteningUnflattening) {
   testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
       /* seed */ 1337,
@@ -382,7 +382,7 @@ TEST(
 }
 
 TEST(
-    ShadowTreeLifecyleTest,
+    ShadowTreeLifecycleTest,
     unstableSmallerTreeMoreIterationsExtensiveFlatteningUnflattening) {
   testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
       /* seed */ 1337,
@@ -393,7 +393,7 @@ TEST(
 
 // failing test case found 4-25-2021
 TEST(
-    ShadowTreeLifecyleTest,
+    ShadowTreeLifecycleTest,
     unstableSmallerTreeMoreIterationsExtensiveFlatteningUnflattening_1167342011) {
   testShadowNodeTreeLifeCycleExtensiveFlatteningUnflattening(
       /* seed */ 1167342011,
@@ -404,7 +404,7 @@ TEST(
 
 // You may uncomment this - locally only! - to generate failing seeds.
 // TEST(
-//     ShadowTreeLifecyleTest,
+//     ShadowTreeLifecycleTest,
 //     unstableSmallerTreeMoreIterationsExtensiveFlatteningUnflatteningManyRandom)
 //     {
 //   std::random_device device;

package/ReactCommon/react/renderer/mounting/tests/StackingContextTest.cpp

@@ -769,16 +769,16 @@ TEST_F(StackingContextTest, zIndexAndFlattenedNodes) {
 
   testViewTree_([](StubViewTree const &viewTree) {
     // 5 views in total.
-    EXPECT_EQ(viewTree.size(), 5);
+    EXPECT_EQ(viewTree.size(), 8);
 
-    // The root view has all 4 subviews.
-    EXPECT_EQ(viewTree.getRootStubView().children.size(), 4);
+    // The root view has all 5 subviews.
+    EXPECT_EQ(viewTree.getRootStubView().children.size(), 5);
 
-    // The root view subviews are [10, 9, 5, 3].
-    EXPECT_EQ(viewTree.getRootStubView().children.at(0)->tag, 10);
-    EXPECT_EQ(viewTree.getRootStubView().children.at(1)->tag, 9);
-    EXPECT_EQ(viewTree.getRootStubView().children.at(2)->tag, 5);
-    EXPECT_EQ(viewTree.getRootStubView().children.at(3)->tag, 3);
+    // The root view subviews are [6, 10, 9, 5].
+    EXPECT_EQ(viewTree.getRootStubView().children.at(0)->tag, 6);
+    EXPECT_EQ(viewTree.getRootStubView().children.at(1)->tag, 10);
+    EXPECT_EQ(viewTree.getRootStubView().children.at(2)->tag, 9);
+    EXPECT_EQ(viewTree.getRootStubView().children.at(3)->tag, 5);
   });
 }
 

package/ReactCommon/react/renderer/mounting/tests/StateReconciliationTest.cpp

@@ -32,8 +32,8 @@ class DummyShadowTreeDelegate : public ShadowTreeDelegate {
   };
 
   void shadowTreeDidFinishTransaction(
-      ShadowTree const &shadowTree,
-      MountingCoordinator::Shared const &mountingCoordinator) const override{};
+      MountingCoordinator::Shared mountingCoordinator,
+      bool mountSynchronously) const override{};
 };
 
 inline ShadowNode const *findDescendantNode(

package/ReactCommon/react/renderer/runtimescheduler/BUCK

@@ -49,6 +49,7 @@ rn_xplat_cxx_library(
     deps = [
         "//xplat/folly:dynamic",
         react_native_xplat_target("runtimeexecutor:runtimeexecutor"),
+        react_native_xplat_target("react/renderer/core:core"),
         react_native_xplat_target("react/renderer/debug:debug"),
         react_native_xplat_target("butter:butter"),
         react_native_xplat_target("callinvoker:callinvoker"),

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

@@ -6,6 +6,7 @@
  */
 
 #include "RuntimeScheduler.h"
+#include "SchedulerPriorityUtils.h"
 
 #include <utility>
 #include "ErrorUtils.h"
@@ -19,8 +20,7 @@ RuntimeScheduler::RuntimeScheduler(
     std::function<RuntimeSchedulerTimePoint()> now)
     : runtimeExecutor_(std::move(runtimeExecutor)), now_(std::move(now)) {}
 
-void RuntimeScheduler::scheduleWork(
-    std::function<void(jsi::Runtime &)> callback) const {
+void RuntimeScheduler::scheduleWork(RawCallback callback) const {
   runtimeAccessRequests_ += 1;
 
   runtimeExecutor_(
@@ -34,7 +34,20 @@ void RuntimeScheduler::scheduleWork(
 std::shared_ptr<Task> RuntimeScheduler::scheduleTask(
     SchedulerPriority priority,
     jsi::Function callback) {
-  auto expirationTime = now() + timeoutForSchedulerPriority(priority);
+  auto expirationTime = now_() + timeoutForSchedulerPriority(priority);
+  auto task =
+      std::make_shared<Task>(priority, std::move(callback), expirationTime);
+  taskQueue_.push(task);
+
+  scheduleWorkLoopIfNecessary();
+
+  return task;
+}
+
+std::shared_ptr<Task> RuntimeScheduler::scheduleTask(
+    SchedulerPriority priority,
+    RawCallback callback) {
+  auto expirationTime = now_() + timeoutForSchedulerPriority(priority);
   auto task =
       std::make_shared<Task>(priority, std::move(callback), expirationTime);
   taskQueue_.push(task);
@@ -64,8 +77,7 @@ RuntimeSchedulerTimePoint RuntimeScheduler::now() const noexcept {
   return now_();
 }
 
-void RuntimeScheduler::executeNowOnTheSameThread(
-    std::function<void(jsi::Runtime &runtime)> callback) {
+void RuntimeScheduler::executeNowOnTheSameThread(RawCallback callback) {
   runtimeAccessRequests_ += 1;
   executeSynchronouslyOnSameThread_CAN_DEADLOCK(
       runtimeExecutor_,

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

@@ -35,7 +35,7 @@ class RuntimeScheduler final {
   RuntimeScheduler(RuntimeScheduler &&) = delete;
   RuntimeScheduler &operator=(RuntimeScheduler &&) = delete;
 
-  void scheduleWork(std::function<void(jsi::Runtime &)> callback) const;
+  void scheduleWork(RawCallback callback) const;
 
   /*
    * Grants access to the runtime synchronously on the caller's thread.
@@ -44,8 +44,7 @@ class RuntimeScheduler final {
    * by dispatching a synchronous event via event emitter in your native
    * component.
    */
-  void executeNowOnTheSameThread(
-      std::function<void(jsi::Runtime &runtime)> callback);
+  void executeNowOnTheSameThread(RawCallback callback);
 
   /*
    * Adds a JavaScript callback to priority queue with given priority.
@@ -57,6 +56,10 @@ class RuntimeScheduler final {
       SchedulerPriority priority,
       jsi::Function callback);
 
+  std::shared_ptr<Task> scheduleTask(
+      SchedulerPriority priority,
+      RawCallback callback);
+
   /*
    * Cancelled task will never be executed.
    *

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

@@ -6,10 +6,10 @@
  */
 
 #include "RuntimeSchedulerBinding.h"
-#include "SchedulerPriority.h"
+#include <ReactCommon/SchedulerPriority.h>
+#include "SchedulerPriorityUtils.h"
 #include "primitives.h"
 
-#include <react/debug/react_native_assert.h>
 #include <chrono>
 #include <memory>
 #include <utility>
@@ -151,7 +151,7 @@ jsi::Value RuntimeSchedulerBinding::get(
         });
   }
 
-  // TODO: remmove this, as it's deprecated in the JS scheduler
+  // TODO: remove this, as it's deprecated in the JS scheduler
   if (propertyName == "unstable_getCurrentPriorityLevel") {
     return jsi::Function::createFromHostFunction(
         runtime,

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

@@ -15,18 +15,27 @@ RuntimeSchedulerCallInvoker::RuntimeSchedulerCallInvoker(
     std::weak_ptr<RuntimeScheduler> runtimeScheduler)
     : runtimeScheduler_(std::move(runtimeScheduler)) {}
 
-void RuntimeSchedulerCallInvoker::invokeAsync(std::function<void()> &&func) {
+void RuntimeSchedulerCallInvoker::invokeAsync(CallFunc &&func) {
   if (auto runtimeScheduler = runtimeScheduler_.lock()) {
     runtimeScheduler->scheduleWork(
         [func = std::move(func)](jsi::Runtime &) { func(); });
   }
 }
 
-void RuntimeSchedulerCallInvoker::invokeSync(std::function<void()> &&func) {
+void RuntimeSchedulerCallInvoker::invokeSync(CallFunc &&func) {
   if (auto runtimeScheduler = runtimeScheduler_.lock()) {
     runtimeScheduler->executeNowOnTheSameThread(
         [func = std::move(func)](jsi::Runtime &) { func(); });
   }
 }
 
+void RuntimeSchedulerCallInvoker::invokeAsync(
+    SchedulerPriority priority,
+    CallFunc &&func) {
+  if (auto runtimeScheduler = runtimeScheduler_.lock()) {
+    runtimeScheduler->scheduleTask(
+        priority, [func = std::move(func)](jsi::Runtime &) { func(); });
+  }
+}
+
 } // namespace facebook::react

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

@@ -14,15 +14,16 @@ namespace facebook {
 namespace react {
 
 /*
- * Exposes RuntimeScheduler to native modules. All calls invonked on JavaScript
+ * Exposes RuntimeScheduler to native modules. All calls invoked on JavaScript
  * queue from native modules will be funneled through RuntimeScheduler.
  */
 class RuntimeSchedulerCallInvoker : public CallInvoker {
  public:
   RuntimeSchedulerCallInvoker(std::weak_ptr<RuntimeScheduler> runtimeScheduler);
 
-  void invokeAsync(std::function<void()> &&func) override;
-  void invokeSync(std::function<void()> &&func) override;
+  void invokeAsync(CallFunc &&func) override;
+  void invokeSync(CallFunc &&func) override;
+  void invokeAsync(SchedulerPriority priority, CallFunc &&func) override;
 
  private:
   /*

package/ReactCommon/react/renderer/runtimescheduler/{SchedulerPriority.h → SchedulerPriorityUtils.h}

@@ -7,19 +7,11 @@
 
 #pragma once
 
+#include <ReactCommon/SchedulerPriority.h>
 #include <react/debug/react_native_assert.h>
 #include <chrono>
 
-namespace facebook {
-namespace react {
-
-enum class SchedulerPriority : int {
-  ImmediatePriority = 1,
-  UserBlockingPriority = 2,
-  NormalPriority = 3,
-  LowPriority = 4,
-  IdlePriority = 5,
-};
+namespace facebook::react {
 
 static constexpr std::underlying_type<SchedulerPriority>::type serialize(
     SchedulerPriority schedulerPriority) {
@@ -61,21 +53,4 @@ static inline std::chrono::milliseconds timeoutForSchedulerPriority(
   }
 }
 
-static inline std::string debugValueForSchedulerPriority(
-    SchedulerPriority schedulerPriority) {
-  switch (schedulerPriority) {
-    case SchedulerPriority::ImmediatePriority:
-      return "SchedulerPriority::ImmediatePriority";
-    case SchedulerPriority::UserBlockingPriority:
-      return "SchedulerPriority::UserBlockingPriority";
-    case SchedulerPriority::NormalPriority:
-      return "SchedulerPriority::NormalPriority";
-    case SchedulerPriority::LowPriority:
-      return "SchedulerPriority::LowPriority";
-    case SchedulerPriority::IdlePriority:
-      return "SchedulerPriority::IdlePriority";
-  }
-}
-
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react