react-native-worklets 0.3.0 → 0.4.0-bundle-mode-preview-1

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

@@ -10,10 +10,7 @@
 #include <fbjni/fbjni.h>
 #endif // __ANDROID__
 
-#include <jsi/jsi.h>
-
 #include <memory>
-#include <string>
 #include <utility>
 
 using namespace facebook;
@@ -27,137 +24,58 @@ WorkletsModuleProxy::WorkletsModuleProxy(
     const std::shared_ptr<MessageQueueThread> &jsQueue,
     const std::shared_ptr<CallInvoker> &jsCallInvoker,
     const std::shared_ptr<UIScheduler> &uiScheduler,
+    std::function<bool()> &&isJavaScriptThread,
     std::function<void(std::function<void(const double)>)>
-        &&forwardedRequestAnimationFrame)
-    : WorkletsModuleProxySpec(jsCallInvoker),
-      isDevBundle_(isDevBundleFromRNRuntime(rnRuntime)),
+        &&forwardedRequestAnimationFrame,
+    const std::shared_ptr<const BigStringBuffer> &script,
+    const std::string &sourceUrl)
+    : isDevBundle_(isDevBundleFromRNRuntime(rnRuntime)),
       jsQueue_(jsQueue),
-      jsScheduler_(std::make_shared<JSScheduler>(rnRuntime, jsCallInvoker)),
-      uiScheduler_(uiScheduler),
-      uiWorkletRuntime_(std::make_shared<WorkletRuntime>(
+      jsScheduler_(std::make_shared<JSScheduler>(
           rnRuntime,
-          jsQueue,
-          jsScheduler_,
-          "Reanimated UI runtime",
-          true /* supportsLocking */,
-          isDevBundle_)),
-      animationFrameBatchinator_(std::make_shared<AnimationFrameBatchinator>(
-          uiWorkletRuntime_->getJSIRuntime(),
-          std::move(forwardedRequestAnimationFrame))) {
+          jsCallInvoker,
+          std::move(isJavaScriptThread))),
+      uiScheduler_(uiScheduler),
+      script_(script),
+      sourceUrl_(sourceUrl),
+      runtimeManager_(std::make_shared<RuntimeManager>()),
+      uiWorkletRuntime_(
+          runtimeManager_->createUninitializedUIRuntime(jsQueue_)) {
+  /**
+   * We must call `init` in the body of the constructor, because
+   * JSIWorkletsModuleProxy needs a weak_ptr to the UI Runtime.
+   */
+  uiWorkletRuntime_->init(createJSIWorkletsModuleProxy());
+
+  animationFrameBatchinator_ = std::make_shared<AnimationFrameBatchinator>(
+      uiWorkletRuntime_->getJSIRuntime(),
+      std::move(forwardedRequestAnimationFrame));
+
   UIRuntimeDecorator::decorate(
       uiWorkletRuntime_->getJSIRuntime(),
       animationFrameBatchinator_->getJsiRequestAnimationFrame());
 }
 
-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,
+std::shared_ptr<JSIWorkletsModuleProxy>
+WorkletsModuleProxy::createJSIWorkletsModuleProxy() const {
+  assert(
+      uiWorkletRuntime_ != nullptr &&
+      "UI Worklet Runtime must be initialized before creating JSI proxy.");
+  return std::make_shared<JSIWorkletsModuleProxy>(
+      isDevBundle_,
+      script_,
+      sourceUrl_,
       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);
+      uiScheduler_,
+      runtimeManager_,
+      uiWorkletRuntime_);
 }
 
-jsi::Value WorkletsModuleProxy::scheduleOnRuntime(
-    jsi::Runtime &rt,
-    const jsi::Value &workletRuntimeValue,
-    const jsi::Value &shareableWorkletValue) {
-  worklets::scheduleOnRuntime(rt, workletRuntimeValue, shareableWorkletValue);
-  return jsi::Value::undefined();
+WorkletsModuleProxy::~WorkletsModuleProxy() {
+  animationFrameBatchinator_.reset();
+  jsQueue_->quitSynchronous();
+  uiWorkletRuntime_.reset();
 }
 
 auto isDevBundleFromRNRuntime(jsi::Runtime &rnRuntime) -> bool {

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

@@ -1,11 +1,14 @@
 #pragma once
 
 #include <cxxreact/MessageQueueThread.h>
+#include <jsi/jsi.h>
+#include <jsireact/JSIExecutor.h>
 #include <worklets/AnimationFrameQueue/AnimationFrameBatchinator.h>
-#include <worklets/NativeModules/WorkletsModuleProxySpec.h>
+#include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
 #include <worklets/Tools/JSScheduler.h>
 #include <worklets/Tools/SingleInstanceChecker.h>
 #include <worklets/Tools/UIScheduler.h>
+#include <worklets/WorkletRuntime/RuntimeManager.h>
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 
 #include <memory>
@@ -14,53 +17,20 @@
 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,
       const std::shared_ptr<MessageQueueThread> &jsQueue,
       const std::shared_ptr<CallInvoker> &jsCallInvoker,
       const std::shared_ptr<UIScheduler> &uiScheduler,
+      std::function<bool()> &&isJavaScriptQueue,
       std::function<void(std::function<void(const double)>)>
-          &&forwardedRequestAnimationFrame);
+          &&forwardedRequestAnimationFrame,
+      const std::shared_ptr<const BigStringBuffer> &script,
+      const std::string &sourceUrl);
 
-  ~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 +49,9 @@ class WorkletsModuleProxy
     return uiWorkletRuntime_;
   }
 
+  [[nodiscard]] std::shared_ptr<JSIWorkletsModuleProxy>
+  createJSIWorkletsModuleProxy() const;
+
   [[nodiscard]] inline bool isDevBundle() const {
     return isDevBundle_;
   }
@@ -88,6 +61,9 @@ class WorkletsModuleProxy
   const std::shared_ptr<MessageQueueThread> jsQueue_;
   const std::shared_ptr<JSScheduler> jsScheduler_;
   const std::shared_ptr<UIScheduler> uiScheduler_;
+  const std::shared_ptr<const BigStringBuffer> script_;
+  const std::string sourceUrl_;
+  const std::shared_ptr<RuntimeManager> runtimeManager_;
   std::shared_ptr<WorkletRuntime> uiWorkletRuntime_;
   std::shared_ptr<AnimationFrameBatchinator> animationFrameBatchinator_;
 #ifndef NDEBUG

package/Common/cpp/worklets/Registries/WorkletRuntimeRegistry.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
 
 #include <mutex>
 #include <set>
@@ -30,7 +31,7 @@ class WorkletRuntimeRegistry {
 
  public:
   static bool isRuntimeAlive(jsi::Runtime *runtime) {
-    assert(runtime != nullptr);
+    react_native_assert(runtime != nullptr && "runtime is nullptr");
     std::lock_guard<std::mutex> lock(mutex_);
     return registry_.find(runtime) != registry_.end();
   }

package/Common/cpp/worklets/Resources/ValueUnpacker.cpp

@@ -48,7 +48,7 @@ const char ValueUnpackerCode[] =
     fun.__remoteFunction = objectToUnpack;
     return fun;
   } else {
-    throw new Error("[Worklets] Data type in category \"".concat(category, "\" not recognized by value unpacker: \"").concat(_toString(objectToUnpack), "\"."));
+    throw new Error("[Worklets] Data type in category \"".concat(category, "\" not recognized by value unpacker: \"").concat(globalThis._toString(objectToUnpack), "\"."));
   }
 })VALUE_UNPACKER";
 } // namespace worklets

package/Common/cpp/worklets/SharedItems/Shareables.cpp

@@ -1,3 +1,4 @@
+#include <jsi/jsi.h>
 #include <worklets/SharedItems/Shareables.h>
 
 using namespace facebook;
@@ -6,7 +7,7 @@ namespace worklets {
 
 jsi::Function getValueUnpacker(jsi::Runtime &rt) {
   auto valueUnpacker = rt.global().getProperty(rt, "__valueUnpacker");
-  assert(valueUnpacker.isObject() && "valueUnpacker not found");
+  react_native_assert(valueUnpacker.isObject() && "valueUnpacker not found");
   return valueUnpacker.asObject(rt).asFunction(rt);
 }
 
@@ -47,23 +48,14 @@ jsi::Value makeShareableClone(
   if (value.isObject()) {
     auto object = value.asObject(rt);
     if (!object.getProperty(rt, "__workletHash").isUndefined()) {
-      if (shouldRetainRemote.isBool() && shouldRetainRemote.getBool()) {
-        shareable =
-            std::make_shared<RetainingShareable<ShareableWorklet>>(rt, object);
-      } else {
-        shareable = std::make_shared<ShareableWorklet>(rt, object);
-      }
+      // We pass `false` because this function is invoked only
+      // by `makeShareableCloneOnUIRecursive` which doesn't
+      // make Retaining Shareables.
+      return makeShareableWorklet(rt, object, false);
     } else if (!object.getProperty(rt, "__init").isUndefined()) {
-      shareable = std::make_shared<ShareableHandle>(rt, object);
+      return makeShareableInitializer(rt, object);
     } else if (object.isFunction(rt)) {
-      auto function = object.asFunction(rt);
-      if (function.isHostFunction(rt)) {
-        shareable =
-            std::make_shared<ShareableHostFunction>(rt, std::move(function));
-      } else {
-        shareable =
-            std::make_shared<ShareableRemoteFunction>(rt, std::move(function));
-      }
+      return makeShareableFunction(rt, object.asFunction(rt));
     } else if (object.isArray(rt)) {
       if (shouldRetainRemote.isBool() && shouldRetainRemote.getBool()) {
         shareable = std::make_shared<RetainingShareable<ShareableArray>>(
@@ -116,32 +108,132 @@ jsi::Value makeShareableClone(
 }
 
 jsi::Value makeShareableString(jsi::Runtime &rt, const jsi::String &string) {
-  auto shareable = std::make_shared<ShareableString>(string.utf8(rt));
+  const auto shareable = std::make_shared<ShareableString>(string.utf8(rt));
   return ShareableJSRef::newHostObject(rt, shareable);
 }
 
 jsi::Value makeShareableNumber(jsi::Runtime &rt, double number) {
-  auto shareable = std::make_shared<ShareableScalar>(number);
+  const auto shareable = std::make_shared<ShareableScalar>(number);
   return ShareableJSRef::newHostObject(rt, shareable);
 }
 
 jsi::Value makeShareableBoolean(jsi::Runtime &rt, bool boolean) {
-  auto shareable = std::make_shared<ShareableScalar>(boolean);
+  const auto shareable = std::make_shared<ShareableScalar>(boolean);
   return ShareableJSRef::newHostObject(rt, shareable);
 }
 
 jsi::Value makeShareableBigInt(jsi::Runtime &rt, const jsi::BigInt &bigint) {
-  auto shareable = std::make_shared<ShareableBigInt>(rt, bigint);
+  const auto shareable = std::make_shared<ShareableBigInt>(rt, bigint);
   return ShareableJSRef::newHostObject(rt, shareable);
 }
 
 jsi::Value makeShareableUndefined(jsi::Runtime &rt) {
-  auto shareable = std::make_shared<ShareableScalar>();
+  const auto shareable = std::make_shared<ShareableScalar>();
   return ShareableJSRef::newHostObject(rt, shareable);
 }
 
 jsi::Value makeShareableNull(jsi::Runtime &rt) {
-  auto shareable = std::make_shared<ShareableScalar>(nullptr);
+  const auto shareable = std::make_shared<ShareableScalar>(nullptr);
+  return ShareableJSRef::newHostObject(rt, shareable);
+}
+
+jsi::Value makeShareableWorklet(
+    jsi::Runtime &rt,
+    const jsi::Object &object,
+    const bool &shouldRetainRemote) {
+  std::shared_ptr<Shareable> shareable;
+  if (shouldRetainRemote) {
+    shareable =
+        std::make_shared<RetainingShareable<ShareableWorklet>>(rt, object);
+  } else {
+    shareable = std::make_shared<ShareableWorklet>(rt, object);
+  }
+  return ShareableJSRef::newHostObject(rt, shareable);
+}
+
+jsi::Value makeShareableInitializer(
+    jsi::Runtime &rt,
+    const jsi::Object &initializerObject) {
+  const auto shareable =
+      std::make_shared<ShareableInitializer>(rt, initializerObject);
+  return ShareableJSRef::newHostObject(rt, shareable);
+}
+
+jsi::Value makeShareableFunction(jsi::Runtime &rt, jsi::Function function) {
+  std::shared_ptr<Shareable> shareable;
+  if (function.isHostFunction(rt)) {
+    shareable =
+        std::make_shared<ShareableHostFunction>(rt, std::move(function));
+  } else {
+    shareable =
+        std::make_shared<ShareableRemoteFunction>(rt, std::move(function));
+  }
+  return ShareableJSRef::newHostObject(rt, shareable);
+}
+
+jsi::Value makeShareableArray(
+    jsi::Runtime &rt,
+    const jsi::Array &array,
+    const jsi::Value &shouldRetainRemote) {
+  std::shared_ptr<Shareable> shareable;
+  if (shouldRetainRemote.isBool() && shouldRetainRemote.getBool()) {
+    shareable = std::make_shared<RetainingShareable<ShareableArray>>(rt, array);
+  } else {
+    shareable = std::make_shared<ShareableArray>(rt, array);
+  }
+  return ShareableJSRef::newHostObject(rt, shareable);
+}
+
+jsi::Value makeShareableMap(
+    jsi::Runtime &rt,
+    const jsi::Array &keys,
+    const jsi::Array &values) {
+  auto shareable = std::make_shared<ShareableMap>(rt, keys, values);
+  return ShareableJSRef::newHostObject(rt, shareable);
+}
+
+jsi::Value makeShareableSet(jsi::Runtime &rt, const jsi::Array &values) {
+  auto shareable = std::make_shared<ShareableSet>(rt, values);
+  return ShareableJSRef::newHostObject(rt, shareable);
+}
+
+jsi::Value makeShareableHostObject(
+    jsi::Runtime &rt,
+    const std::shared_ptr<jsi::HostObject> &value) {
+  const auto shareable = std::make_shared<ShareableHostObject>(rt, value);
+  return ShareableJSRef::newHostObject(rt, shareable);
+}
+
+jsi::Value makeShareableTurboModuleLike(
+    jsi::Runtime &rt,
+    const jsi::Object &object,
+    const std::shared_ptr<jsi::HostObject> &proto) {
+  const auto shareable =
+      std::make_shared<ShareableTurboModuleLike>(rt, object, proto);
+  return ShareableJSRef::newHostObject(rt, shareable);
+}
+
+jsi::Value makeShareableImport(
+    jsi::Runtime &rt,
+    const double source,
+    const jsi::String &imported) {
+  auto shareable = std::make_shared<ShareableImport>(rt, source, imported);
+  return ShareableJSRef::newHostObject(rt, shareable);
+}
+
+jsi::Value makeShareableObject(
+    jsi::Runtime &rt,
+    jsi::Object object,
+    bool shouldRetainRemote,
+    const jsi::Value &nativeStateSource) {
+  std::shared_ptr<Shareable> shareable;
+  if (shouldRetainRemote) {
+    shareable = std::make_shared<RetainingShareable<ShareableObject>>(
+        rt, object, nativeStateSource);
+  } else {
+    shareable =
+        std::make_shared<ShareableObject>(rt, object, nativeStateSource);
+  }
   return ShareableJSRef::newHostObject(rt, shareable);
 }
 
@@ -263,6 +355,61 @@ jsi::Value ShareableObject::toJSValue(jsi::Runtime &rt) {
   return obj;
 }
 
+ShareableMap::ShareableMap(
+    jsi::Runtime &rt,
+    const jsi::Array &keys,
+    const jsi::Array &values)
+    : Shareable(MapType) {
+  auto size = keys.size(rt);
+  react_native_assert(
+      size == values.size(rt) &&
+      "Keys and values arrays must have the same size.");
+  data_.reserve(size);
+  for (size_t i = 0; i < size; i++) {
+    auto key = extractShareableOrThrow(rt, keys.getValueAtIndex(rt, i));
+    auto value = extractShareableOrThrow(rt, values.getValueAtIndex(rt, i));
+    data_.emplace_back(key, value);
+  }
+}
+
+jsi::Value ShareableMap::toJSValue(jsi::Runtime &rt) {
+  const auto keyValues = jsi::Array(rt, data_.size());
+  for (size_t i = 0, size = data_.size(); i < size; i++) {
+    const auto pair = jsi::Array(rt, 2);
+    pair.setValueAtIndex(rt, 0, data_[i].first->toJSValue(rt));
+    pair.setValueAtIndex(rt, 1, data_[i].second->toJSValue(rt));
+    keyValues.setValueAtIndex(rt, i, std::move(pair));
+  }
+
+  const auto &global = rt.global();
+  auto map = global.getPropertyAsFunction(rt, "Map").callAsConstructor(
+      rt, std::move(keyValues));
+
+  return map;
+}
+
+ShareableSet::ShareableSet(jsi::Runtime &rt, const jsi::Array &values)
+    : Shareable(SetType) {
+  auto size = values.size(rt);
+  data_.reserve(size);
+  for (size_t i = 0; i < size; i++) {
+    data_.push_back(extractShareableOrThrow(rt, values.getValueAtIndex(rt, i)));
+  }
+}
+
+jsi::Value ShareableSet::toJSValue(jsi::Runtime &rt) {
+  const auto values = jsi::Array(rt, data_.size());
+  for (size_t i = 0, size = data_.size(); i < size; i++) {
+    values.setValueAtIndex(rt, i, data_[i]->toJSValue(rt));
+  }
+
+  const auto &global = rt.global();
+  auto set = global.getPropertyAsFunction(rt, "Set").callAsConstructor(
+      rt, std::move(values));
+
+  return set;
+}
+
 jsi::Value ShareableHostObject::toJSValue(jsi::Runtime &rt) {
   return jsi::Object::createFromHostObject(rt, hostObject_);
 }
@@ -273,7 +420,7 @@ jsi::Value ShareableHostFunction::toJSValue(jsi::Runtime &rt) {
 }
 
 jsi::Value ShareableWorklet::toJSValue(jsi::Runtime &rt) {
-  assert(
+  react_native_assert(
       std::any_of(
           data_.cbegin(),
           data_.cend(),
@@ -284,6 +431,24 @@ jsi::Value ShareableWorklet::toJSValue(jsi::Runtime &rt) {
       rt, obj, jsi::String::createFromAscii(rt, "Worklet"));
 }
 
+jsi::Value ShareableImport::toJSValue(jsi::Runtime &rt) {
+  /**
+   * The only way to obtain a module in runtime is to use the Metro's require
+   * method implementation, which is injected into the global object as `__r`.
+   */
+  const auto metroRequire = rt.global().getProperty(rt, "__r");
+  if (metroRequire.isUndefined()) {
+    return jsi::Value::undefined();
+  }
+
+  const auto imported = jsi::String::createFromUtf8(rt, imported_);
+  return metroRequire.asObject(rt)
+      .asFunction(rt)
+      .call(rt, source_)
+      .asObject(rt)
+      .getProperty(rt, imported);
+}
+
 jsi::Value ShareableRemoteFunction::toJSValue(jsi::Runtime &rt) {
   if (&rt == runtime_) {
     return jsi::Value(rt, *function_);
@@ -300,7 +465,7 @@ jsi::Value ShareableRemoteFunction::toJSValue(jsi::Runtime &rt) {
   }
 }
 
-jsi::Value ShareableHandle::toJSValue(jsi::Runtime &rt) {
+jsi::Value ShareableInitializer::toJSValue(jsi::Runtime &rt) {
   if (remoteValue_ == nullptr) {
     auto initObj = initializer_->toJSValue(rt);
     auto value = std::make_unique<jsi::Value>(getValueUnpacker(rt).call(
@@ -353,4 +518,15 @@ jsi::Value ShareableScalar::toJSValue(jsi::Runtime &) {
   }
 }
 
+jsi::Value ShareableTurboModuleLike::toJSValue(jsi::Runtime &rt) {
+  auto obj = properties_->toJSValue(rt).asObject(rt);
+  const auto prototype = proto_->toJSValue(rt);
+  rt.global()
+      .getPropertyAsObject(rt, "Object")
+      .getPropertyAsFunction(rt, "setPrototypeOf")
+      .call(rt, obj, prototype);
+
+  return obj;
+}
+
 } // namespace worklets