react-native-worklets 0.3.0 → 0.4.0-nightly-20250521-922379cf5

package/Common/cpp/worklets/NativeModules/JSIWorkletsModuleProxy.cpp

@@ -0,0 +1,288 @@
+#include <react/renderer/uimanager/UIManagerBinding.h>
+#include <react/renderer/uimanager/primitives.h>
+
+#include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/SharedItems/Shareables.h>
+#include <worklets/Tools/Defs.h>
+#include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
+
+#ifdef __ANDROID__
+#include <fbjni/fbjni.h>
+#endif // __ANDROID__
+
+#include <string>
+#include <utility>
+
+using namespace facebook;
+
+namespace worklets {
+
+inline void scheduleOnUI(
+    const std::shared_ptr<UIScheduler> &uiScheduler,
+    const std::weak_ptr<WorkletRuntime> &weakUIWorkletRuntime,
+    jsi::Runtime &rt,
+    const jsi::Value &worklet) {
+  auto shareableWorklet = extractShareableOrThrow<ShareableWorklet>(
+      rt, worklet, "[Worklets] Only worklets can be scheduled to run on UI.");
+  uiScheduler->scheduleOnUI([shareableWorklet, weakUIWorkletRuntime]() {
+    // This callback can outlive the WorkletsModuleProxy object during the
+    // invalidation of React Native. This happens when WorkletsModuleProxy
+    // destructor is called on the JS thread and the UI thread is
+    // executing callbacks from the `scheduleOnUI` queue. Therefore, we
+    // need to make sure it's still alive before we try to access it.
+    auto uiWorkletRuntime = weakUIWorkletRuntime.lock();
+    if (!uiWorkletRuntime) {
+      return;
+    }
+
+#if JS_RUNTIME_HERMES
+    // JSI's scope defined here allows for JSI-objects to be cleared up
+    // after each runtime loop. Within these loops we typically create
+    // some temporary JSI objects and hence it allows for such objects to
+    // be garbage collected much sooner. Apparently the scope API is only
+    // supported on Hermes at the moment.
+    const auto scope = jsi::Scope(uiWorkletRuntime->getJSIRuntime());
+#endif // JS_RUNTIME_HERMES
+
+    uiWorkletRuntime->runGuarded(shareableWorklet);
+  });
+}
+
+inline jsi::Value executeOnUIRuntimeSync(
+    const std::weak_ptr<WorkletRuntime> &weakUIWorkletRuntime,
+    jsi::Runtime &rt,
+    const jsi::Value &worklet) {
+  if (auto uiWorkletRuntime = weakUIWorkletRuntime.lock()) {
+    return uiWorkletRuntime->executeSync(rt, worklet);
+  }
+  return jsi::Value::undefined();
+}
+
+inline jsi::Value createWorkletRuntime(
+    const std::shared_ptr<MessageQueueThread> &jsQueue,
+    const std::shared_ptr<JSScheduler> &jsScheduler,
+    std::shared_ptr<JSIWorkletsModuleProxy> jsiWorkletsModuleProxy,
+    const bool isDevBundle,
+    jsi::Runtime &rt,
+    const jsi::Value &name,
+    const jsi::Value &initializer) {
+  auto workletRuntime = std::make_shared<WorkletRuntime>(
+      rt,
+      std::move(jsiWorkletsModuleProxy),
+      jsQueue,
+      jsScheduler,
+      name.asString(rt).utf8(rt),
+      true /* supportsLocking */,
+      isDevBundle);
+  auto initializerShareable = extractShareableOrThrow<ShareableWorklet>(
+      rt, initializer, "[Worklets] Initializer must be a worklet.");
+  workletRuntime->runGuarded(initializerShareable);
+  return jsi::Object::createFromHostObject(rt, workletRuntime);
+}
+
+JSIWorkletsModuleProxy::JSIWorkletsModuleProxy(
+    const bool isDevBundle,
+    const std::shared_ptr<MessageQueueThread> &jsQueue,
+    const std::shared_ptr<JSScheduler> &jsScheduler,
+    const std::shared_ptr<UIScheduler> &uiScheduler,
+    std::shared_ptr<WorkletRuntime> uiWorkletRuntime)
+    : jsi::HostObject(),
+      isDevBundle_(isDevBundle),
+      jsQueue_(jsQueue),
+      jsScheduler_(jsScheduler),
+      uiScheduler_(uiScheduler),
+      uiWorkletRuntime_(uiWorkletRuntime) {}
+
+JSIWorkletsModuleProxy::JSIWorkletsModuleProxy(
+    const JSIWorkletsModuleProxy &other)
+    : jsi::HostObject(),
+      isDevBundle_(other.isDevBundle_),
+      jsQueue_(other.jsQueue_),
+      jsScheduler_(other.jsScheduler_),
+      uiScheduler_(other.uiScheduler_),
+      uiWorkletRuntime_(other.uiWorkletRuntime_) {}
+
+JSIWorkletsModuleProxy::~JSIWorkletsModuleProxy() = default;
+
+std::vector<jsi::PropNameID> JSIWorkletsModuleProxy::getPropertyNames(
+    jsi::Runtime &rt) {
+  std::vector<jsi::PropNameID> propertyNames;
+
+  propertyNames.emplace_back(
+      jsi::PropNameID::forAscii(rt, "makeShareableClone"));
+  propertyNames.emplace_back(
+      jsi::PropNameID::forAscii(rt, "makeShareableBigInt"));
+  propertyNames.emplace_back(
+      jsi::PropNameID::forAscii(rt, "makeShareableBoolean"));
+  propertyNames.emplace_back(
+      jsi::PropNameID::forAscii(rt, "makeShareableNull"));
+  propertyNames.emplace_back(
+      jsi::PropNameID::forAscii(rt, "makeShareableNumber"));
+  propertyNames.emplace_back(
+      jsi::PropNameID::forAscii(rt, "makeShareableString"));
+  propertyNames.emplace_back(
+      jsi::PropNameID::forAscii(rt, "makeShareableUndefined"));
+
+  propertyNames.emplace_back(jsi::PropNameID::forAscii(rt, "scheduleOnUI"));
+  propertyNames.emplace_back(
+      jsi::PropNameID::forAscii(rt, "executeOnUIRuntimeSync"));
+  propertyNames.emplace_back(
+      jsi::PropNameID::forAscii(rt, "createWorkletRuntime"));
+  propertyNames.emplace_back(
+      jsi::PropNameID::forAscii(rt, "scheduleOnRuntime"));
+
+  return propertyNames;
+}
+
+jsi::Value JSIWorkletsModuleProxy::get(
+    jsi::Runtime &rt,
+    const jsi::PropNameID &propName) {
+  const auto name = propName.utf8(rt);
+  if (name == "makeShareableClone") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        propName,
+        3,
+        [](jsi::Runtime &rt,
+           const jsi::Value &thisValue,
+           const jsi::Value *args,
+           size_t count) {
+          return makeShareableClone(rt, args[0], args[1], args[2]);
+        });
+  }
+  if (name == "makeShareableBigInt") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        propName,
+        1,
+        [](jsi::Runtime &rt,
+           const jsi::Value &thisValue,
+           const jsi::Value *args,
+           size_t count) {
+          return makeShareableBigInt(rt, args[0].asBigInt(rt));
+        });
+  }
+  if (name == "makeShareableBoolean") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        propName,
+        1,
+        [](jsi::Runtime &rt,
+           const jsi::Value &thisValue,
+           const jsi::Value *args,
+           size_t count) {
+          return makeShareableBoolean(rt, args[0].asBool());
+        });
+  }
+  if (name == "makeShareableNumber") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        propName,
+        1,
+        [](jsi::Runtime &rt,
+           const jsi::Value &thisValue,
+           const jsi::Value *args,
+           size_t count) {
+          return makeShareableNumber(rt, args[0].asNumber());
+        });
+  }
+  if (name == "makeShareableNull") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        propName,
+        0,
+        [](jsi::Runtime &rt,
+           const jsi::Value &thisValue,
+           const jsi::Value *args,
+           size_t count) { return makeShareableNull(rt); });
+  }
+  if (name == "makeShareableString") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        propName,
+        1,
+        [](jsi::Runtime &rt,
+           const jsi::Value &thisValue,
+           const jsi::Value *args,
+           size_t count) {
+          return makeShareableString(rt, args[0].asString(rt));
+        });
+  }
+  if (name == "makeShareableUndefined") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        propName,
+        0,
+        [](jsi::Runtime &rt,
+           const jsi::Value &thisValue,
+           const jsi::Value *args,
+           size_t count) { return makeShareableUndefined(rt); });
+  }
+  if (name == "scheduleOnUI") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        propName,
+        1,
+        [uiScheduler = uiScheduler_, uiWorkletRuntime = uiWorkletRuntime_](
+            jsi::Runtime &rt,
+            const jsi::Value &thisValue,
+            const jsi::Value *args,
+            size_t count) {
+          scheduleOnUI(uiScheduler, uiWorkletRuntime, rt, args[0]);
+          return jsi::Value::undefined();
+        });
+  } else if (name == "executeOnUIRuntimeSync") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        propName,
+        1,
+        [uiWorkletRuntime = uiWorkletRuntime_](
+            jsi::Runtime &rt,
+            const jsi::Value &thisValue,
+            const jsi::Value *args,
+            size_t count) {
+          return executeOnUIRuntimeSync(uiWorkletRuntime, rt, args[0]);
+        });
+  } else if (name == "createWorkletRuntime") {
+    auto clone = std::make_shared<JSIWorkletsModuleProxy>(*this);
+    return jsi::Function::createFromHostFunction(
+        rt,
+        propName,
+        2,
+        [jsQueue = jsQueue_,
+         jsScheduler = jsScheduler_,
+         isDevBundle = isDevBundle_,
+         clone](
+            jsi::Runtime &rt,
+            const jsi::Value &thisValue,
+            const jsi::Value *args,
+            size_t count) {
+          return createWorkletRuntime(
+              jsQueue,
+              jsScheduler,
+              std::move(clone),
+              isDevBundle,
+              rt,
+              args[0],
+              args[1]);
+          return jsi::Value::undefined();
+        });
+  } else if (name == "scheduleOnRuntime") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        propName,
+        2,
+        [](jsi::Runtime &rt,
+           const jsi ::Value &thisValue,
+           const jsi::Value *args,
+           size_t count) {
+          worklets::scheduleOnRuntime(rt, args[0], args[1]);
+          return jsi::Value::undefined();
+        });
+  }
+
+  return jsi::Value::undefined();
+}
+
+} // namespace worklets

package/Common/cpp/worklets/NativeModules/JSIWorkletsModuleProxy.h

@@ -0,0 +1,51 @@
+
+#pragma once
+
+#include <react/renderer/uimanager/UIManagerBinding.h>
+#include <react/renderer/uimanager/primitives.h>
+
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/SharedItems/Shareables.h>
+#include <worklets/Tools/Defs.h>
+#include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
+
+#ifdef __ANDROID__
+#include <fbjni/fbjni.h>
+#endif // __ANDROID__
+
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <vector>
+
+using namespace facebook;
+
+namespace worklets {
+
+class JSIWorkletsModuleProxy : public jsi::HostObject {
+ public:
+  explicit JSIWorkletsModuleProxy(
+      const bool isDevBundle,
+      const std::shared_ptr<MessageQueueThread> &jsQueue,
+      const std::shared_ptr<JSScheduler> &jsScheduler,
+      const std::shared_ptr<UIScheduler> &uiScheduler,
+      std::shared_ptr<WorkletRuntime> uiWorkletRuntime);
+
+  JSIWorkletsModuleProxy(const JSIWorkletsModuleProxy &other);
+
+  ~JSIWorkletsModuleProxy() override;
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propName) override;
+
+ private:
+  const bool isDevBundle_;
+  const std::shared_ptr<MessageQueueThread> jsQueue_;
+  const std::shared_ptr<JSScheduler> jsScheduler_;
+  const std::shared_ptr<UIScheduler> uiScheduler_;
+  // TODO: Make it non-nullptr on the UI runtime.
+  std::weak_ptr<WorkletRuntime> uiWorkletRuntime_;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/NativeModules/WorkletsModuleProxy.cpp

@@ -1,6 +1,7 @@
 #include <react/renderer/uimanager/UIManagerBinding.h>
 #include <react/renderer/uimanager/primitives.h>
 
+#include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
 #include <worklets/NativeModules/WorkletsModuleProxy.h>
 #include <worklets/SharedItems/Shareables.h>
 #include <worklets/Tools/Defs.h>
@@ -10,10 +11,7 @@
 #include <fbjni/fbjni.h>
 #endif // __ANDROID__
 
-#include <jsi/jsi.h>
-
 #include <memory>
-#include <string>
 #include <utility>
 
 using namespace facebook;
@@ -29,13 +27,13 @@ WorkletsModuleProxy::WorkletsModuleProxy(
     const std::shared_ptr<UIScheduler> &uiScheduler,
     std::function<void(std::function<void(const double)>)>
         &&forwardedRequestAnimationFrame)
-    : WorkletsModuleProxySpec(jsCallInvoker),
-      isDevBundle_(isDevBundleFromRNRuntime(rnRuntime)),
+    : isDevBundle_(isDevBundleFromRNRuntime(rnRuntime)),
       jsQueue_(jsQueue),
       jsScheduler_(std::make_shared<JSScheduler>(rnRuntime, jsCallInvoker)),
       uiScheduler_(uiScheduler),
       uiWorkletRuntime_(std::make_shared<WorkletRuntime>(
           rnRuntime,
+          createJSIWorkletsModuleProxy(),
           jsQueue,
           jsScheduler_,
           "Reanimated UI runtime",
@@ -49,117 +47,18 @@ WorkletsModuleProxy::WorkletsModuleProxy(
       animationFrameBatchinator_->getJsiRequestAnimationFrame());
 }
 
+std::shared_ptr<jsi::HostObject>
+WorkletsModuleProxy::createJSIWorkletsModuleProxy() const {
+  return std::make_shared<JSIWorkletsModuleProxy>(
+      isDevBundle_, jsQueue_, jsScheduler_, uiScheduler_, uiWorkletRuntime_);
+}
+
 WorkletsModuleProxy::~WorkletsModuleProxy() {
   animationFrameBatchinator_.reset();
   jsQueue_->quitSynchronous();
   uiWorkletRuntime_.reset();
 }
 
-jsi::Value WorkletsModuleProxy::makeShareableClone(
-    jsi::Runtime &rt,
-    const jsi::Value &value,
-    const jsi::Value &shouldRetainRemote,
-    const jsi::Value &nativeStateSource) {
-  // TODO: It might be a good idea to rename one of these methods to avoid
-  // confusion.
-  return worklets::makeShareableClone(
-      rt, value, shouldRetainRemote, nativeStateSource);
-}
-
-jsi::Value WorkletsModuleProxy::makeShareableString(
-    jsi::Runtime &rt,
-    const jsi::String &string) {
-  return worklets::makeShareableString(rt, string);
-}
-
-jsi::Value WorkletsModuleProxy::makeShareableNumber(
-    jsi::Runtime &rt,
-    double number) {
-  return worklets::makeShareableNumber(rt, number);
-}
-
-jsi::Value WorkletsModuleProxy::makeShareableBoolean(
-    jsi::Runtime &rt,
-    bool boolean) {
-  return worklets::makeShareableBoolean(rt, boolean);
-}
-
-jsi::Value WorkletsModuleProxy::makeShareableBigInt(
-    jsi::Runtime &rt,
-    const jsi::BigInt &bigint) {
-  return worklets::makeShareableBigInt(rt, bigint);
-}
-
-jsi::Value WorkletsModuleProxy::makeShareableUndefined(jsi::Runtime &rt) {
-  return worklets::makeShareableUndefined(rt);
-}
-
-jsi::Value WorkletsModuleProxy::makeShareableNull(jsi::Runtime &rt) {
-  return worklets::makeShareableNull(rt);
-}
-
-void WorkletsModuleProxy::scheduleOnUI(
-    jsi::Runtime &rt,
-    const jsi::Value &worklet) {
-  auto shareableWorklet = extractShareableOrThrow<ShareableWorklet>(
-      rt, worklet, "[Worklets] Only worklets can be scheduled to run on UI.");
-  uiScheduler_->scheduleOnUI([shareableWorklet, weakThis = weak_from_this()] {
-    // This callback can outlive the WorkletsModuleProxy object during the
-    // invalidation of React Native. This happens when WorkletsModuleProxy
-    // destructor is called on the JS thread and the UI thread is executing
-    // callbacks from the `scheduleOnUI` queue. Therefore, we need to
-    // make sure it's still alive before we try to access it.
-    auto strongThis = weakThis.lock();
-    if (!strongThis) {
-      return;
-    }
-
-    auto uiWorkletRuntime = strongThis->getUIWorkletRuntime();
-
-#if JS_RUNTIME_HERMES
-    // JSI's scope defined here allows for JSI-objects to be cleared up
-    // after each runtime loop. Within these loops we typically create some
-    // temporary JSI objects and hence it allows for such objects to be
-    // garbage collected much sooner. Apparently the scope API is only
-    // supported on Hermes at the moment.
-    const auto scope = jsi::Scope(uiWorkletRuntime->getJSIRuntime());
-#endif // JS_RUNTIME_HERMES
-
-    uiWorkletRuntime->runGuarded(shareableWorklet);
-  });
-}
-
-jsi::Value WorkletsModuleProxy::executeOnUIRuntimeSync(
-    jsi::Runtime &rt,
-    const jsi::Value &worklet) {
-  return uiWorkletRuntime_->executeSync(rt, worklet);
-}
-
-jsi::Value WorkletsModuleProxy::createWorkletRuntime(
-    jsi::Runtime &rt,
-    const jsi::Value &name,
-    const jsi::Value &initializer) {
-  auto workletRuntime = std::make_shared<WorkletRuntime>(
-      rt,
-      jsQueue_,
-      jsScheduler_,
-      name.asString(rt).utf8(rt),
-      true /* supportsLocking */,
-      isDevBundle_);
-  auto initializerShareable = extractShareableOrThrow<ShareableWorklet>(
-      rt, initializer, "[Worklets] Initializer must be a worklet.");
-  workletRuntime->runGuarded(initializerShareable);
-  return jsi::Object::createFromHostObject(rt, workletRuntime);
-}
-
-jsi::Value WorkletsModuleProxy::scheduleOnRuntime(
-    jsi::Runtime &rt,
-    const jsi::Value &workletRuntimeValue,
-    const jsi::Value &shareableWorkletValue) {
-  worklets::scheduleOnRuntime(rt, workletRuntimeValue, shareableWorkletValue);
-  return jsi::Value::undefined();
-}
-
 auto isDevBundleFromRNRuntime(jsi::Runtime &rnRuntime) -> bool {
   const auto rtDev = rnRuntime.global().getProperty(rnRuntime, "__DEV__");
   return rtDev.isBool() && rtDev.asBool();

package/Common/cpp/worklets/NativeModules/WorkletsModuleProxy.h

@@ -1,21 +1,19 @@
 #pragma once
 
 #include <cxxreact/MessageQueueThread.h>
+#include <jsi/jsi.h>
 #include <worklets/AnimationFrameQueue/AnimationFrameBatchinator.h>
-#include <worklets/NativeModules/WorkletsModuleProxySpec.h>
 #include <worklets/Tools/JSScheduler.h>
 #include <worklets/Tools/SingleInstanceChecker.h>
 #include <worklets/Tools/UIScheduler.h>
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 
 #include <memory>
-#include <string>
 
 namespace worklets {
 
 class WorkletsModuleProxy
-    : public WorkletsModuleProxySpec,
-      public std::enable_shared_from_this<WorkletsModuleProxy> {
+    : public std::enable_shared_from_this<WorkletsModuleProxy> {
  public:
   explicit WorkletsModuleProxy(
       jsi::Runtime &rnRuntime,
@@ -25,42 +23,7 @@ class WorkletsModuleProxy
       std::function<void(std::function<void(const double)>)>
           &&forwardedRequestAnimationFrame);
 
-  ~WorkletsModuleProxy() override;
-
-  jsi::Value makeShareableClone(
-      jsi::Runtime &rt,
-      const jsi::Value &value,
-      const jsi::Value &shouldRetainRemote,
-      const jsi::Value &nativeStateSource) override;
-
-  jsi::Value makeShareableString(jsi::Runtime &rt, const jsi::String &string)
-      override;
-
-  jsi::Value makeShareableNumber(jsi::Runtime &rt, double number) override;
-
-  jsi::Value makeShareableBoolean(jsi::Runtime &rt, bool boolean) override;
-
-  jsi::Value makeShareableBigInt(jsi::Runtime &rt, const jsi::BigInt &bigint)
-      override;
-
-  jsi::Value makeShareableUndefined(jsi::Runtime &rt) override;
-
-  jsi::Value makeShareableNull(jsi::Runtime &rt) override;
-
-  void scheduleOnUI(jsi::Runtime &rt, const jsi::Value &worklet) override;
-
-  jsi::Value executeOnUIRuntimeSync(jsi::Runtime &rt, const jsi::Value &worklet)
-      override;
-
-  jsi::Value createWorkletRuntime(
-      jsi::Runtime &rt,
-      const jsi::Value &name,
-      const jsi::Value &initializer) override;
-
-  jsi::Value scheduleOnRuntime(
-      jsi::Runtime &rt,
-      const jsi::Value &workletRuntimeValue,
-      const jsi::Value &shareableWorkletValue) override;
+  ~WorkletsModuleProxy();
 
   [[nodiscard]] inline std::shared_ptr<MessageQueueThread> getJSQueue() const {
     return jsQueue_;
@@ -79,6 +42,9 @@ class WorkletsModuleProxy
     return uiWorkletRuntime_;
   }
 
+  [[nodiscard]] std::shared_ptr<jsi::HostObject> createJSIWorkletsModuleProxy()
+      const;
+
   [[nodiscard]] inline bool isDevBundle() const {
     return isDevBundle_;
   }

package/Common/cpp/worklets/Tools/WorkletsJSIUtils.cpp

@@ -1,4 +1,7 @@
 #include <worklets/Tools/WorkletsJSIUtils.h>
+
+#include <memory>
+#include <sstream>
 #include <vector>
 
 using namespace facebook;
@@ -23,4 +26,15 @@ jsi::Array convertStringToArray(
   return matrix;
 }
 
+jsi::Object optimizedFromHostObject(
+    jsi::Runtime &rt,
+    std::shared_ptr<jsi::HostObject> &&hostObject) {
+  auto optimizedObject = jsi::Object(rt);
+  for (const auto &propertyName : hostObject->getPropertyNames(rt)) {
+    optimizedObject.setProperty(
+        rt, propertyName, hostObject->get(rt, propertyName));
+  }
+  return optimizedObject;
+}
+
 } // namespace worklets::jsi_utils

package/Common/cpp/worklets/Tools/WorkletsJSIUtils.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <jsi/jsi.h>
-#include <sstream>
+#include <memory>
 #include <string>
 #include <tuple>
 #include <utility>
@@ -196,4 +196,8 @@ jsi::Array convertStringToArray(
     const std::string &value,
     const unsigned int expectedSize);
 
+jsi::Object optimizedFromHostObject(
+    jsi::Runtime &rt,
+    std::shared_ptr<jsi::HostObject> &&hostObject);
+
 } // namespace worklets::jsi_utils

package/Common/cpp/worklets/WorkletRuntime/RNRuntimeWorkletDecorator.cpp

@@ -1,11 +1,13 @@
 #include <worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h>
 #include <worklets/WorkletRuntime/WorkletRuntimeCollector.h>
 
+#include <utility>
+
 namespace worklets {
 
 void RNRuntimeWorkletDecorator::decorate(
     jsi::Runtime &rnRuntime,
-    const std::shared_ptr<WorkletsModuleProxy> &workletsModuleProxy) {
+    jsi::Object &&jsiWorkletsModuleProxy) {
   rnRuntime.global().setProperty(rnRuntime, "_WORKLET", false);
 
   // TODO: Remove _IS_FABRIC sometime in the future
@@ -13,9 +15,7 @@ void RNRuntimeWorkletDecorator::decorate(
   rnRuntime.global().setProperty(rnRuntime, "_IS_FABRIC", true);
 
   rnRuntime.global().setProperty(
-      rnRuntime,
-      "__workletsModuleProxy",
-      jsi::Object::createFromHostObject(rnRuntime, workletsModuleProxy));
+      rnRuntime, "__workletsModuleProxy", std::move(jsiWorkletsModuleProxy));
 
   WorkletRuntimeCollector::install(rnRuntime);
 }

package/Common/cpp/worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h

@@ -13,7 +13,7 @@ class RNRuntimeWorkletDecorator {
  public:
   static void decorate(
       jsi::Runtime &rnRuntime,
-      const std::shared_ptr<WorkletsModuleProxy> &workletsModuleProxy);
+      jsi::Object &&jsiWorkletsModuleProxy);
 };
 
 } // namespace worklets

package/Common/cpp/worklets/WorkletRuntime/WorkletRuntime.cpp

@@ -1,6 +1,7 @@
 #include <worklets/Resources/ValueUnpacker.h>
 #include <worklets/Tools/Defs.h>
 #include <worklets/Tools/JSISerializer.h>
+#include <worklets/Tools/WorkletsJSIUtils.h>
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 #include <worklets/WorkletRuntime/WorkletRuntimeCollector.h>
 #include <worklets/WorkletRuntime/WorkletRuntimeDecorator.h>
@@ -82,6 +83,7 @@ static std::shared_ptr<jsi::Runtime> makeRuntime(
 
 WorkletRuntime::WorkletRuntime(
     jsi::Runtime &rnRuntime,
+    std::shared_ptr<jsi::HostObject> &&jsiWorkletsModuleProxy,
     const std::shared_ptr<MessageQueueThread> &jsQueue,
     const std::shared_ptr<JSScheduler> &jsScheduler,
     const std::string &name,
@@ -100,7 +102,16 @@ WorkletRuntime::WorkletRuntime(
       name_(name) {
   jsi::Runtime &rt = *runtime_;
   WorkletRuntimeCollector::install(rt);
-  WorkletRuntimeDecorator::decorate(rt, name, jsScheduler, isDevBundle);
+
+  auto optimizedJsiWorkletsModuleProxy =
+      jsi_utils::optimizedFromHostObject(rt, std::move(jsiWorkletsModuleProxy));
+
+  WorkletRuntimeDecorator::decorate(
+      rt,
+      name,
+      jsScheduler,
+      isDevBundle,
+      std::move(optimizedJsiWorkletsModuleProxy));
 
   auto valueUnpackerBuffer =
       std::make_shared<const jsi::StringBuffer>(ValueUnpackerCode);

package/Common/cpp/worklets/WorkletRuntime/WorkletRuntime.h

@@ -22,6 +22,7 @@ class WorkletRuntime : public jsi::HostObject,
  public:
   explicit WorkletRuntime(
       jsi::Runtime &rnRuntime,
+      std::shared_ptr<jsi::HostObject> &&jsiWorkletsModuleProxy,
       const std::shared_ptr<MessageQueueThread> &jsQueue,
       const std::shared_ptr<JSScheduler> &jsScheduler,
       const std::string &name,

package/Common/cpp/worklets/WorkletRuntime/WorkletRuntimeDecorator.cpp

@@ -5,6 +5,7 @@
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 #include <worklets/WorkletRuntime/WorkletRuntimeDecorator.h>
 
+#include <utility>
 #include <vector>
 
 namespace worklets {
@@ -40,7 +41,8 @@ void WorkletRuntimeDecorator::decorate(
     jsi::Runtime &rt,
     const std::string &name,
     const std::shared_ptr<JSScheduler> &jsScheduler,
-    const bool isDevBundle) {
+    const bool isDevBundle,
+    jsi::Object &&jsiWorkletsModuleProxy) {
   // resolves "ReferenceError: Property 'global' doesn't exist at ..."
   rt.global().setProperty(rt, "global", rt.global());
 
@@ -54,6 +56,9 @@ void WorkletRuntimeDecorator::decorate(
 
   rt.global().setProperty(rt, "__DEV__", isDevBundle);
 
+  rt.global().setProperty(
+      rt, "__workletsModuleProxy", std::move(jsiWorkletsModuleProxy));
+
 #ifndef NDEBUG
   auto evalWithSourceUrl = [](jsi::Runtime &rt,
                               const jsi::Value &thisValue,

package/Common/cpp/worklets/WorkletRuntime/WorkletRuntimeDecorator.h

@@ -17,7 +17,8 @@ class WorkletRuntimeDecorator {
       jsi::Runtime &rt,
       const std::string &name,
       const std::shared_ptr<JSScheduler> &jsScheduler,
-      const bool isDevBundle);
+      const bool isDevBundle,
+      jsi::Object &&jsiWorkletsModuleProxy);
 };
 
 } // namespace worklets

package/android/src/main/cpp/worklets/android/WorkletsModule.cpp

@@ -1,5 +1,6 @@
 #include <react/jni/JMessageQueueThread.h>
 
+#include <worklets/Tools/WorkletsJSIUtils.h>
 #include <worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h>
 #include <worklets/android/AnimationFrameCallback.h>
 #include <worklets/android/WorkletsModule.h>
@@ -25,7 +26,12 @@ WorkletsModule::WorkletsModule(
           jsCallInvoker,
           uiScheduler,
           getForwardedRequestAnimationFrame())) {
-  RNRuntimeWorkletDecorator::decorate(*rnRuntime_, workletsModuleProxy_);
+  auto jsiWorkletsModuleProxy =
+      workletsModuleProxy_->createJSIWorkletsModuleProxy();
+  auto optimizedJsiWorkletsModuleProxy = jsi_utils::optimizedFromHostObject(
+      *rnRuntime_, std::move(jsiWorkletsModuleProxy));
+  RNRuntimeWorkletDecorator::decorate(
+      *rnRuntime_, std::move(optimizedJsiWorkletsModuleProxy));
 }
 
 jni::local_ref<WorkletsModule::jhybriddata> WorkletsModule::initHybrid(

package/apple/worklets/apple/WorkletsModule.mm

@@ -1,4 +1,5 @@
 #import <worklets/Tools/SingleInstanceChecker.h>
+#import <worklets/Tools/WorkletsJSIUtils.h>
 #import <worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h>
 #import <worklets/apple/AnimationFrameQueue.h>
 #import <worklets/apple/AssertJavaScriptQueue.h>
@@ -64,7 +65,10 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(installTurboModule)
       });
   workletsModuleProxy_ = std::make_shared<WorkletsModuleProxy>(
       rnRuntime, jsQueue, jsCallInvoker, uiScheduler, std::move(forwardedRequestAnimationFrame));
-  RNRuntimeWorkletDecorator::decorate(rnRuntime, workletsModuleProxy_);
+  auto jsiWorkletsModuleProxy = workletsModuleProxy_->createJSIWorkletsModuleProxy();
+  auto optimizedJsiWorkletsModuleProxy =
+      worklets::jsi_utils::optimizedFromHostObject(rnRuntime, std::move(jsiWorkletsModuleProxy));
+  RNRuntimeWorkletDecorator::decorate(rnRuntime, std::move(optimizedJsiWorkletsModuleProxy));
 
   return @YES;
 }

package/lib/module/WorkletsModule/NativeWorklets.js

@@ -20,19 +20,7 @@ class NativeWorklets {
       throw new WorkletsError(`Native part of Worklets doesn't seem to be initialized.
 See https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#native-part-of-reanimated-doesnt-seem-to-be-initialized for more details.`);
     }
-    this.#workletsModuleProxy = {
-      scheduleOnUI: global.__workletsModuleProxy.scheduleOnUI,
-      scheduleOnRuntime: global.__workletsModuleProxy.scheduleOnRuntime,
-      executeOnUIRuntimeSync: global.__workletsModuleProxy.executeOnUIRuntimeSync,
-      createWorkletRuntime: global.__workletsModuleProxy.createWorkletRuntime,
-      makeShareableClone: global.__workletsModuleProxy.makeShareableClone,
-      makeShareableString: global.__workletsModuleProxy.makeShareableString,
-      makeShareableNumber: global.__workletsModuleProxy.makeShareableNumber,
-      makeShareableBoolean: global.__workletsModuleProxy.makeShareableBoolean,
-      makeShareableBigInt: global.__workletsModuleProxy.makeShareableBigInt,
-      makeShareableUndefined: global.__workletsModuleProxy.makeShareableUndefined,
-      makeShareableNull: global.__workletsModuleProxy.makeShareableNull
-    };
+    this.#workletsModuleProxy = global.__workletsModuleProxy;
     this.#shareableNull = this.#workletsModuleProxy.makeShareableNull();
     this.#shareableUndefined = this.#workletsModuleProxy.makeShareableUndefined();
     this.#shareableTrue = this.#workletsModuleProxy.makeShareableBoolean(true);

package/lib/module/WorkletsModule/NativeWorklets.js.map

@@ -1 +1 @@
-{"version":3,"names":["WorkletsTurboModule","WorkletsError","createNativeWorkletsModule","NativeWorklets","workletsModuleProxy","shareableUndefined","shareableNull","shareableTrue","shareableFalse","constructor","global","__workletsModuleProxy","undefined","installTurboModule","scheduleOnUI","scheduleOnRuntime","executeOnUIRuntimeSync","createWorkletRuntime","makeShareableClone","makeShareableString","makeShareableNumber","makeShareableBoolean","makeShareableBigInt","makeShareableUndefined","makeShareableNull","value","shouldPersistRemote","nativeStateSource","str","num","bool","bigInt","shareable","name","initializer","workletRuntime","shareableWorklet"],"sourceRoot":"../../../src","sources":["WorkletsModule/NativeWorklets.ts"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["WorkletsTurboModule","WorkletsError","createNativeWorkletsModule","NativeWorklets","workletsModuleProxy","shareableUndefined","shareableNull","shareableTrue","shareableFalse","constructor","global","__workletsModuleProxy","undefined","installTurboModule","makeShareableNull","makeShareableUndefined","makeShareableBoolean","makeShareableClone","value","shouldPersistRemote","nativeStateSource","makeShareableString","str","makeShareableNumber","num","bool","makeShareableBigInt","bigInt","scheduleOnUI","shareable","executeOnUIRuntimeSync","createWorkletRuntime","name","initializer","scheduleOnRuntime","workletRuntime","shareableWorklet"],"sourceRoot":"../../../src","sources":["WorkletsModule/NativeWorklets.ts"],"mappings":"AAAA;AACA,YAAY;;AAEZ,SAASA,mBAAmB,QAAQ,mBAAU;AAC9C,SAASC,aAAa,QAAQ,qBAAkB;AAMhD,OAAO,SAASC,0BAA0BA,CAAA,EAAoB;EAC5D,OAAO,IAAIC,cAAc,CAAC,CAAC;AAC7B;AAEA,MAAMA,cAAc,CAAC;EACnB,CAACC,mBAAmB;EACpB,CAACC,kBAAkB;EACnB,CAACC,aAAa;EACd,CAACC,aAAa;EACd,CAACC,cAAc;EAEfC,WAAWA,CAAA,EAAG;IACZ,IAAIC,MAAM,CAACC,qBAAqB,KAAKC,SAAS,EAAE;MAC9CZ,mBAAmB,EAAEa,kBAAkB,CAAC,CAAC;IAC3C;IACA,IAAIH,MAAM,CAACC,qBAAqB,KAAKC,SAAS,EAAE;MAC9C,MAAM,IAAIX,aAAa,CACrB;AACR,6JACM,CAAC;IACH;IACA,IAAI,CAAC,CAACG,mBAAmB,GAAGM,MAAM,CAACC,qBAAqB;IACxD,IAAI,CAAC,CAACL,aAAa,GAAG,IAAI,CAAC,CAACF,mBAAmB,CAACU,iBAAiB,CAAC,CAAC;IACnE,IAAI,CAAC,CAACT,kBAAkB,GACtB,IAAI,CAAC,CAACD,mBAAmB,CAACW,sBAAsB,CAAC,CAAC;IACpD,IAAI,CAAC,CAACR,aAAa,GAAG,IAAI,CAAC,CAACH,mBAAmB,CAACY,oBAAoB,CAAC,IAAI,CAAC;IAC1E,IAAI,CAAC,CAACR,cAAc,GAClB,IAAI,CAAC,CAACJ,mBAAmB,CAACY,oBAAoB,CAAC,KAAK,CAAC;EACzD;EAEAC,kBAAkBA,CAChBC,KAAa,EACbC,mBAA4B,EAC5BC,iBAA0B,EAC1B;IACA,OAAO,IAAI,CAAC,CAAChB,mBAAmB,CAACa,kBAAkB,CACjDC,KAAK,EACLC,mBAAmB,EACnBC,iBACF,CAAC;EACH;EAEAC,mBAAmBA,CAACC,GAAW,EAAE;IAC/B,OAAO,IAAI,CAAC,CAAClB,mBAAmB,CAACiB,mBAAmB,CAACC,GAAG,CAAC;EAC3D;EAEAC,mBAAmBA,CAACC,GAAW,EAAE;IAC/B,OAAO,IAAI,CAAC,CAACpB,mBAAmB,CAACmB,mBAAmB,CAACC,GAAG,CAAC;EAC3D;EAEAR,oBAAoBA,CAACS,IAAa,EAAE;IAClC,OAAOA,IAAI,GAAG,IAAI,CAAC,CAAClB,aAAa,GAAG,IAAI,CAAC,CAACC,cAAc;EAC1D;EAEAkB,mBAAmBA,CAACC,MAAc,EAAE;IAClC,OAAO,IAAI,CAAC,CAACvB,mBAAmB,CAACsB,mBAAmB,CAACC,MAAM,CAAC;EAC9D;EAEAZ,sBAAsBA,CAAA,EAAG;IACvB,OAAO,IAAI,CAAC,CAACV,kBAAkB;EACjC;EAEAS,iBAAiBA,CAAA,EAAG;IAClB,OAAO,IAAI,CAAC,CAACR,aAAa;EAC5B;EAEAsB,YAAYA,CAASC,SAA+B,EAAE;IACpD,OAAO,IAAI,CAAC,CAACzB,mBAAmB,CAACwB,YAAY,CAACC,SAAS,CAAC;EAC1D;EAEAC,sBAAsBA,CACpBD,SAA+B,EACtB;IACT,OAAO,IAAI,CAAC,CAACzB,mBAAmB,CAAC0B,sBAAsB,CAACD,SAAS,CAAC;EACpE;EAEAE,oBAAoBA,CAACC,IAAY,EAAEC,WAAqC,EAAE;IACxE,OAAO,IAAI,CAAC,CAAC7B,mBAAmB,CAAC2B,oBAAoB,CAACC,IAAI,EAAEC,WAAW,CAAC;EAC1E;EAEAC,iBAAiBA,CACfC,cAA8B,EAC9BC,gBAAiC,EACjC;IACA,OAAO,IAAI,CAAC,CAAChC,mBAAmB,CAAC8B,iBAAiB,CAChDC,cAAc,EACdC,gBACF,CAAC;EACH;AACF","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-worklets",
-  "version": "0.3.0",
+  "version": "0.4.0-nightly-20250521-922379cf5",
   "description": "The React Native multithreading library",
   "keywords": [
     "react-native",

package/src/WorkletsModule/NativeWorklets.ts

@@ -29,21 +29,7 @@ class NativeWorklets {
 See https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#native-part-of-reanimated-doesnt-seem-to-be-initialized for more details.`
       );
     }
-    this.#workletsModuleProxy = {
-      scheduleOnUI: global.__workletsModuleProxy.scheduleOnUI,
-      scheduleOnRuntime: global.__workletsModuleProxy.scheduleOnRuntime,
-      executeOnUIRuntimeSync:
-        global.__workletsModuleProxy.executeOnUIRuntimeSync,
-      createWorkletRuntime: global.__workletsModuleProxy.createWorkletRuntime,
-      makeShareableClone: global.__workletsModuleProxy.makeShareableClone,
-      makeShareableString: global.__workletsModuleProxy.makeShareableString,
-      makeShareableNumber: global.__workletsModuleProxy.makeShareableNumber,
-      makeShareableBoolean: global.__workletsModuleProxy.makeShareableBoolean,
-      makeShareableBigInt: global.__workletsModuleProxy.makeShareableBigInt,
-      makeShareableUndefined:
-        global.__workletsModuleProxy.makeShareableUndefined,
-      makeShareableNull: global.__workletsModuleProxy.makeShareableNull,
-    };
+    this.#workletsModuleProxy = global.__workletsModuleProxy;
     this.#shareableNull = this.#workletsModuleProxy.makeShareableNull();
     this.#shareableUndefined =
       this.#workletsModuleProxy.makeShareableUndefined();

package/Common/cpp/worklets/NativeModules/WorkletsModuleProxySpec.cpp

@@ -1,139 +0,0 @@
-#include <jsi/jsi.h>
-#include <worklets/NativeModules/WorkletsModuleProxySpec.h>
-
-#include <utility>
-
-#define WORKLETS_SPEC_PREFIX(FN_NAME) \
-  __hostFunction_WorkletsModuleProxySpec_##FN_NAME
-
-namespace worklets {
-
-static jsi::Value WORKLETS_SPEC_PREFIX(makeShareableClone)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
-      ->makeShareableClone(
-          rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
-}
-
-static jsi::Value WORKLETS_SPEC_PREFIX(makeShareableString)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
-      ->makeShareableString(rt, std::move(args[0]).asString(rt));
-}
-
-static jsi::Value WORKLETS_SPEC_PREFIX(makeShareableNumber)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
-      ->makeShareableNumber(rt, std::move(args[0]).asNumber());
-}
-
-static jsi::Value WORKLETS_SPEC_PREFIX(makeShareableBoolean)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
-      ->makeShareableBoolean(rt, std::move(args[0]).asBool());
-}
-
-static jsi::Value WORKLETS_SPEC_PREFIX(makeShareableBigInt)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
-      ->makeShareableBigInt(rt, std::move(args[0]).asBigInt(rt));
-}
-
-static jsi::Value WORKLETS_SPEC_PREFIX(makeShareableUndefined)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
-      ->makeShareableUndefined(rt);
-}
-
-static jsi::Value WORKLETS_SPEC_PREFIX(makeShareableNull)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
-      ->makeShareableNull(rt);
-}
-
-static jsi::Value WORKLETS_SPEC_PREFIX(scheduleOnUI)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  static_cast<WorkletsModuleProxySpec *>(&turboModule)
-      ->scheduleOnUI(rt, std::move(args[0]));
-  return jsi::Value::undefined();
-}
-
-static jsi::Value WORKLETS_SPEC_PREFIX(executeOnUIRuntimeSync)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
-      ->executeOnUIRuntimeSync(rt, std::move(args[0]));
-}
-
-static jsi::Value WORKLETS_SPEC_PREFIX(createWorkletRuntime)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
-      ->createWorkletRuntime(rt, std::move(args[0]), std::move(args[1]));
-}
-
-static jsi::Value WORKLETS_SPEC_PREFIX(scheduleOnRuntime)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
-      ->scheduleOnRuntime(rt, std::move(args[0]), std::move(args[1]));
-}
-
-WorkletsModuleProxySpec::WorkletsModuleProxySpec(
-    const std::shared_ptr<CallInvoker> jsInvoker)
-    : TurboModule("NativeWorklets", jsInvoker) {
-  methodMap_["makeShareableClone"] =
-      MethodMetadata{2, WORKLETS_SPEC_PREFIX(makeShareableClone)};
-  methodMap_["makeShareableString"] =
-      MethodMetadata{1, WORKLETS_SPEC_PREFIX(makeShareableString)};
-  methodMap_["makeShareableNumber"] =
-      MethodMetadata{1, WORKLETS_SPEC_PREFIX(makeShareableNumber)};
-  methodMap_["makeShareableBoolean"] =
-      MethodMetadata{1, WORKLETS_SPEC_PREFIX(makeShareableBoolean)};
-  methodMap_["makeShareableBigInt"] =
-      MethodMetadata{1, WORKLETS_SPEC_PREFIX(makeShareableBigInt)};
-  methodMap_["makeShareableUndefined"] =
-      MethodMetadata{0, WORKLETS_SPEC_PREFIX(makeShareableUndefined)};
-  methodMap_["makeShareableNull"] =
-      MethodMetadata{0, WORKLETS_SPEC_PREFIX(makeShareableNull)};
-  methodMap_["scheduleOnUI"] =
-      MethodMetadata{1, WORKLETS_SPEC_PREFIX(scheduleOnUI)};
-  methodMap_["executeOnUIRuntimeSync"] =
-      MethodMetadata{1, WORKLETS_SPEC_PREFIX(executeOnUIRuntimeSync)};
-  methodMap_["createWorkletRuntime"] =
-      MethodMetadata{2, WORKLETS_SPEC_PREFIX(createWorkletRuntime)};
-  methodMap_["scheduleOnRuntime"] =
-      MethodMetadata{2, WORKLETS_SPEC_PREFIX(scheduleOnRuntime)};
-}
-
-} // namespace worklets

package/Common/cpp/worklets/NativeModules/WorkletsModuleProxySpec.h

@@ -1,61 +0,0 @@
-#pragma once
-
-#include <ReactCommon/CallInvoker.h>
-#include <ReactCommon/TurboModule.h>
-#include <memory>
-#include <string>
-
-using namespace facebook;
-using namespace react;
-
-namespace worklets {
-
-class JSI_EXPORT WorkletsModuleProxySpec : public TurboModule {
- protected:
-  explicit WorkletsModuleProxySpec(
-      const std::shared_ptr<CallInvoker> jsInvoker);
-
- public:
-  // Shareables
-  virtual jsi::Value makeShareableClone(
-      jsi::Runtime &rt,
-      const jsi::Value &value,
-      const jsi::Value &shouldRetainRemote,
-      const jsi::Value &nativeStateSource) = 0;
-
-  virtual jsi::Value makeShareableString(
-      jsi::Runtime &rt,
-      const jsi::String &string) = 0;
-
-  virtual jsi::Value makeShareableNumber(jsi::Runtime &rt, double number) = 0;
-
-  virtual jsi::Value makeShareableBoolean(jsi::Runtime &rt, bool boolean) = 0;
-
-  virtual jsi::Value makeShareableBigInt(
-      jsi::Runtime &rt,
-      const jsi::BigInt &bigint) = 0;
-
-  virtual jsi::Value makeShareableUndefined(jsi::Runtime &rt) = 0;
-
-  virtual jsi::Value makeShareableNull(jsi::Runtime &rt) = 0;
-
-  // Scheduling
-  virtual void scheduleOnUI(jsi::Runtime &rt, const jsi::Value &worklet) = 0;
-
-  virtual jsi::Value executeOnUIRuntimeSync(
-      jsi::Runtime &rt,
-      const jsi::Value &worklet) = 0;
-
-  // Worklet runtime
-  virtual jsi::Value createWorkletRuntime(
-      jsi::Runtime &rt,
-      const jsi::Value &name,
-      const jsi::Value &initializer) = 0;
-
-  virtual jsi::Value scheduleOnRuntime(
-      jsi::Runtime &rt,
-      const jsi::Value &workletRuntimeValue,
-      const jsi::Value &shareableWorkletValue) = 0;
-};
-
-} // namespace worklets