react-native-reanimated 3.0.0-rc.8 → 3.0.0

package/Common/cpp/ReanimatedRuntime/ReanimatedHermesRuntime.cpp

@@ -9,6 +9,7 @@
 #include <jsi/jsi.h>
 
 #include <memory>
+#include <string>
 #include <utility>
 
 #if __has_include(<reacthermes/HermesExecutorFactory.h>)
@@ -41,6 +42,11 @@ class HermesExecutorRuntimeAdapter
     thread_->quitSynchronous();
   }
 
+#if REACT_NATIVE_MINOR_VERSION >= 71
+  facebook::hermes::HermesRuntime &getRuntime() override {
+    return hermesRuntime_;
+  }
+#else
   facebook::jsi::Runtime &getRuntime() override {
     return hermesRuntime_;
   }
@@ -48,6 +54,7 @@ class HermesExecutorRuntimeAdapter
   facebook::hermes::debugger::Debugger &getDebugger() override {
     return hermesRuntime_.getDebugger();
   }
+#endif // REACT_NATIVE_MINOR_VERSION
 
   // This is not empty in the original implementation, but we decided to tickle
   // the runtime by running a small piece of code on every frame as using this
@@ -72,20 +79,62 @@ ReanimatedHermesRuntime::ReanimatedHermesRuntime(
 #if HERMES_ENABLE_DEBUGGER
   auto adapter =
       std::make_unique<HermesExecutorRuntimeAdapter>(*runtime_, jsQueue);
+#if REACT_NATIVE_MINOR_VERSION >= 71
+  debugToken_ = facebook::hermes::inspector::chrome::enableDebugging(
+      std::move(adapter), "Reanimated Runtime");
+#else
   facebook::hermes::inspector::chrome::enableDebugging(
       std::move(adapter), "Reanimated Runtime");
+#endif // REACT_NATIVE_MINOR_VERSION
 #else
   // This is required by iOS, because there is an assertion in the destructor
   // that the thread was indeed `quit` before
   jsQueue->quitSynchronous();
 #endif
+
+#ifdef DEBUG
+  facebook::hermes::HermesRuntime *wrappedRuntime = runtime_.get();
+  jsi::Value evalWithSourceMap = jsi::Function::createFromHostFunction(
+      *runtime_,
+      jsi::PropNameID::forAscii(*runtime_, "evalWithSourceMap"),
+      3,
+      [wrappedRuntime](
+          jsi::Runtime &rt,
+          const jsi::Value &thisValue,
+          const jsi::Value *args,
+          size_t count) -> jsi::Value {
+        auto code = std::make_shared<const jsi::StringBuffer>(
+            args[0].asString(rt).utf8(rt));
+        std::string sourceURL;
+        if (count > 1 && args[1].isString()) {
+          sourceURL = args[1].asString(rt).utf8(rt);
+        }
+        std::shared_ptr<const jsi::Buffer> sourceMap;
+        if (count > 2 && args[2].isString()) {
+          sourceMap = std::make_shared<const jsi::StringBuffer>(
+              args[2].asString(rt).utf8(rt));
+        }
+#if REACT_NATIVE_MINOR_VERSION >= 65
+        return wrappedRuntime->evaluateJavaScriptWithSourceMap(
+            code, sourceMap, sourceURL);
+#else
+        return wrappedRuntime->evaluateJavaScript(code, sourceURL);
+#endif
+      });
+  runtime_->global().setProperty(
+      *runtime_, "evalWithSourceMap", evalWithSourceMap);
+#endif // DEBUG
 }
 
 ReanimatedHermesRuntime::~ReanimatedHermesRuntime() {
 #if HERMES_ENABLE_DEBUGGER
   // We have to disable debugging before the runtime is destroyed.
+#if REACT_NATIVE_MINOR_VERSION >= 71
+  facebook::hermes::inspector::chrome::disableDebugging(debugToken_);
+#else
   facebook::hermes::inspector::chrome::disableDebugging(*runtime_);
-#endif
+#endif // REACT_NATIVE_MINOR_VERSION
+#endif // HERMES_ENABLE_DEBUGGER
 }
 
 } // namespace reanimated

package/Common/cpp/ReanimatedRuntime/ReanimatedHermesRuntime.h

@@ -25,6 +25,10 @@
 #include <hermes/hermes.h>
 #endif
 
+#if REACT_NATIVE_MINOR_VERSION >= 71
+#include <hermes/inspector/chrome/Registration.h>
+#endif
+
 namespace reanimated {
 
 using namespace facebook;
@@ -116,8 +120,13 @@ class ReanimatedHermesRuntime
   ~ReanimatedHermesRuntime();
 
  private:
-  std::shared_ptr<facebook::hermes::HermesRuntime> runtime_;
+  std::unique_ptr<facebook::hermes::HermesRuntime> runtime_;
   ReanimatedReentrancyCheck reentrancyCheck_;
+#if HERMES_ENABLE_DEBUGGER
+#if REACT_NATIVE_MINOR_VERSION >= 71
+  facebook::hermes::inspector::chrome::DebugSessionToken debugToken_;
+#endif // REACT_NATIVE_MINOR_VERSION >= 71
+#endif // HERMES_ENABLE_DEBUGGER
 };
 
 } // namespace reanimated

package/Common/cpp/ReanimatedRuntime/ReanimatedRuntime.cpp

@@ -11,8 +11,12 @@
 #elif JS_RUNTIME_V8
 #include <v8runtime/V8RuntimeFactory.h>
 #else
+#if REACT_NATIVE_MINOR_VERSION >= 71
+#include <jsc/JSCRuntime.h>
+#else
 #include <jsi/JSCRuntime.h>
-#endif
+#endif // REACT_NATIVE_MINOR_VERSION
+#endif // JS_RUNTIME
 
 namespace reanimated {
 

package/Common/cpp/Registries/EventHandlerRegistry.cpp

@@ -10,7 +10,7 @@ void EventHandlerRegistry::registerEventHandler(
   eventHandlers[eventHandler->id] = eventHandler;
 }
 
-void EventHandlerRegistry::unregisterEventHandler(unsigned long id) {
+void EventHandlerRegistry::unregisterEventHandler(uint64_t id) {
   const std::lock_guard<std::mutex> lock(instanceMutex);
   auto handlerIt = eventHandlers.find(id);
   if (handlerIt != eventHandlers.end()) {
@@ -24,13 +24,9 @@ void EventHandlerRegistry::unregisterEventHandler(unsigned long id) {
 
 void EventHandlerRegistry::processEvent(
     jsi::Runtime &rt,
-    std::string eventName,
-#ifdef RCT_NEW_ARCH_ENABLED
-    jsi::Value &eventPayload
-#else
-    std::string eventPayload
-#endif
-    /**/) {
+    double eventTimestamp,
+    const std::string &eventName,
+    const jsi::Value &eventPayload) {
   std::vector<std::shared_ptr<WorkletEventHandler>> handlersForEvent;
   {
     const std::lock_guard<std::mutex> lock(instanceMutex);
@@ -41,38 +37,16 @@ void EventHandlerRegistry::processEvent(
       }
     }
   }
-#ifdef RCT_NEW_ARCH_ENABLED
-  eventPayload.asObject(rt).setProperty(
-      rt, "eventName", jsi::String::createFromUtf8(rt, eventName));
-  for (auto handler : handlersForEvent) {
-    handler->process(rt, eventPayload);
-  }
-#else
-  // We receive here a JS Map with JSON as a value of NativeMap key
-  // { NativeMap: { "jsonProp": "json value" } }
-  // So we need to extract only JSON part
-  std::string delimimter = "NativeMap:";
-  auto positionToSplit = eventPayload.find(delimimter) + delimimter.size();
-  auto lastBracketCharactedPosition = eventPayload.size() - positionToSplit - 1;
-  auto eventJSON =
-      eventPayload.substr(positionToSplit, lastBracketCharactedPosition);
 
-  if (eventJSON.compare(std::string("null")) == 0) {
-    return;
-  }
-
-  auto eventObject = jsi::Value::createFromJsonUtf8(
-      rt, reinterpret_cast<uint8_t *>(&eventJSON[0]), eventJSON.size());
-
-  eventObject.asObject(rt).setProperty(
+  eventPayload.asObject(rt).setProperty(
       rt, "eventName", jsi::String::createFromUtf8(rt, eventName));
   for (auto handler : handlersForEvent) {
-    handler->process(rt, eventObject);
+    handler->process(eventTimestamp, eventPayload);
   }
-#endif
 }
 
-bool EventHandlerRegistry::isAnyHandlerWaitingForEvent(std::string eventName) {
+bool EventHandlerRegistry::isAnyHandlerWaitingForEvent(
+    const std::string &eventName) {
   const std::lock_guard<std::mutex> lock(instanceMutex);
   auto it = eventMappings.find(eventName);
   return (it != eventMappings.end()) && (!(it->second).empty());

package/Common/cpp/Registries/EventHandlerRegistry.h

@@ -18,28 +18,22 @@ class WorkletEventHandler;
 class EventHandlerRegistry {
   std::map<
       std::string,
-      std::unordered_map<unsigned long, std::shared_ptr<WorkletEventHandler>>>
+      std::unordered_map<uint64_t, std::shared_ptr<WorkletEventHandler>>>
       eventMappings;
-  std::map<unsigned long, std::shared_ptr<WorkletEventHandler>> eventHandlers;
+  std::map<uint64_t, std::shared_ptr<WorkletEventHandler>> eventHandlers;
   std::mutex instanceMutex;
 
  public:
   void registerEventHandler(std::shared_ptr<WorkletEventHandler> eventHandler);
-  void unregisterEventHandler(unsigned long id);
+  void unregisterEventHandler(uint64_t id);
 
-#ifdef RCT_NEW_ARCH_ENABLED
   void processEvent(
       jsi::Runtime &rt,
-      std::string eventName,
-      jsi::Value &eventPayload);
-#else
-  void processEvent(
-      jsi::Runtime &rt,
-      std::string eventName,
-      std::string eventPayload);
-#endif
+      double eventTimestamp,
+      const std::string &eventName,
+      const jsi::Value &eventPayload);
 
-  bool isAnyHandlerWaitingForEvent(std::string eventName);
+  bool isAnyHandlerWaitingForEvent(const std::string &eventName);
 };
 
 } // namespace reanimated

package/Common/cpp/SharedItems/Shareables.cpp

@@ -11,9 +11,13 @@ CoreFunction::CoreFunction(
   jsi::Runtime &rt = *runtimeHelper->rnRuntime();
   auto workletObject = workletValue.asObject(rt);
   rnFunction_ = std::make_unique<jsi::Function>(workletObject.asFunction(rt));
-  functionBody_ =
-      workletObject.getProperty(rt, "asString").asString(rt).utf8(rt);
-  location_ = workletObject.getProperty(rt, "__location").asString(rt).utf8(rt);
+  functionBody_ = workletObject.getPropertyAsObject(rt, "__initData")
+                      .getProperty(rt, "code")
+                      .asString(rt)
+                      .utf8(rt);
+  location_ = "worklet_" +
+      std::to_string(static_cast<uint64_t>(
+          workletObject.getProperty(rt, "__workletHash").getNumber()));
 }
 
 std::unique_ptr<jsi::Function> &CoreFunction::getFunction(jsi::Runtime &rt) {
@@ -57,61 +61,8 @@ std::shared_ptr<Shareable> extractShareableOrThrow(
 
 Shareable::~Shareable() {}
 
-#if HAS_JS_WEAK_OBJECTS
-
-jsi::Value RetainingShareable::getJSValue(jsi::Runtime &rt) {
-  jsi::Value value;
-  if (runtimeHelper_->isRNRuntime(rt)) {
-    // TODO: it is suboptimal to generate new object every time getJS is called
-    // on host runtime – the objects we are generating already exists and we
-    // should possibly just grab a hold of such object and use it here instead
-    // of creating a new JS representation. As far as I understand the only
-    // case where it can be realistically called this way is when a shared
-    // value is created and then accessed on the same runtime
-    return toJSValue(rt);
-  } else if (remoteValue_ == nullptr) {
-    value = toJSValue(rt);
-    remoteValue_ = std::make_unique<jsi::WeakObject>(rt, value.asObject(rt));
-  } else {
-    value = remoteValue_->lock(rt);
-    if (value.isUndefined()) {
-      value = toJSValue(rt);
-      remoteValue_ = std::make_unique<jsi::WeakObject>(rt, value.asObject(rt));
-    }
-  }
-  return value;
-}
-
-RetainingShareable::~RetainingShareable() {
-  if (runtimeHelper_->uiRuntimeDestroyed) {
-    // The below use of unique_ptr.release prevents the smart pointer from
-    // calling the destructor of the kept object. This effectively results in
-    // leaking some memory. We do this on purpose, as sometimes we would keep
-    // references to JSI objects past the lifetime of its runtime (e.g., shared
-    // values references from the RN VM holds reference to JSI objects on the
-    // UI runtime). When the UI runtime is terminated, the orphaned JSI objects
-    // would crash the app when their destructors are called, because they
-    // call into a memory that's managed by the terminated runtime. We accept
-    // the tradeoff of leaking memory here, as it has a limited impact. This
-    // scenario can only occur when the React instance is torn down which
-    // happens in development mode during app reloads, or in production when the
-    // app is being shut down gracefully by the system. An alternative solution
-    // would require us to keep track of all JSI values that are in use which
-    // would require additional data structure and compute spent on bookkeeping
-    // that only for the sake of destroying the values in time before the
-    // runtime is terminated. Note that the underlying memory that jsi::Value
-    // refers to is managed by the VM and gets freed along with the runtime.
-    remoteValue_.release();
-  }
-}
-
-#endif // HAS_JS_WEAK_OBJECTS
-
-ShareableArray::ShareableArray(
-    const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
-    jsi::Runtime &rt,
-    const jsi::Array &array)
-    : RetainingShareable(runtimeHelper, rt, ArrayType) {
+ShareableArray::ShareableArray(jsi::Runtime &rt, const jsi::Array &array)
+    : Shareable(ArrayType) {
   auto size = array.size(rt);
   data_.reserve(size);
   for (size_t i = 0; i < size; i++) {
@@ -119,11 +70,8 @@ ShareableArray::ShareableArray(
   }
 }
 
-ShareableObject::ShareableObject(
-    const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
-    jsi::Runtime &rt,
-    const jsi::Object &object)
-    : RetainingShareable(runtimeHelper, rt, ObjectType) {
+ShareableObject::ShareableObject(jsi::Runtime &rt, const jsi::Object &object)
+    : Shareable(ObjectType) {
   auto propertyNames = object.getPropertyNames(rt);
   auto size = propertyNames.size(rt);
   data_.reserve(size);

package/Common/cpp/SharedItems/Shareables.h

@@ -6,21 +6,37 @@
 #include <utility>
 #include <vector>
 
-#ifdef RCT_NEW_ARCH_ENABLED
-#include <react/renderer/uimanager/primitives.h>
-#endif
-
 #include "ReanimatedRuntime.h"
 #include "RuntimeManager.h"
 #include "Scheduler.h"
 
-#define HAS_JS_WEAK_OBJECTS JS_RUNTIME_HERMES
-
 using namespace facebook;
 
 namespace reanimated {
 
-class CoreFunction;
+class JSRuntimeHelper;
+
+// Core functions are not allowed to capture outside variables, otherwise they'd
+// try to access _closure variable which is something we want to avoid for
+// simplicity reasons.
+class CoreFunction {
+ private:
+  std::unique_ptr<jsi::Function> rnFunction_;
+  std::unique_ptr<jsi::Function> uiFunction_;
+  std::string functionBody_;
+  std::string location_;
+  JSRuntimeHelper
+      *runtimeHelper_; // runtime helper holds core function references, so we
+                       // use normal pointer here to avoid ref cycles.
+  std::unique_ptr<jsi::Function> &getFunction(jsi::Runtime &rt);
+
+ public:
+  CoreFunction(JSRuntimeHelper *runtimeHelper, const jsi::Value &workletObject);
+  template <typename... Args>
+  jsi::Value call(jsi::Runtime &rt, Args &&...args) {
+    return getFunction(rt)->call(rt, args...);
+  }
+};
 
 class JSRuntimeHelper {
  private:
@@ -35,8 +51,9 @@ class JSRuntimeHelper {
       const std::shared_ptr<Scheduler> &scheduler)
       : rnRuntime_(rnRuntime), uiRuntime_(uiRuntime), scheduler_(scheduler) {}
 
-  volatile bool uiRuntimeDestroyed;
-  std::shared_ptr<CoreFunction> valueUnpacker;
+  volatile bool uiRuntimeDestroyed = false;
+  std::unique_ptr<CoreFunction> callGuard;
+  std::unique_ptr<CoreFunction> valueUnpacker;
 
   inline jsi::Runtime *uiRuntime() const {
     return uiRuntime_;
@@ -61,27 +78,19 @@ class JSRuntimeHelper {
   void scheduleOnJS(std::function<void()> job) {
     scheduler_->scheduleOnJS(job);
   }
-};
-
-// Core functions are not allowed to capture outside variables, otherwise they'd
-// try to access _closure variable which is something we want to avoid for
-// simplicity reasons.
-class CoreFunction {
- private:
-  std::unique_ptr<jsi::Function> rnFunction_;
-  std::unique_ptr<jsi::Function> uiFunction_;
-  std::string functionBody_;
-  std::string location_;
-  JSRuntimeHelper
-      *runtimeHelper_; // runtime helper holds core function references, so we
-                       // use normal pointer here to avoid ref cycles.
-  std::unique_ptr<jsi::Function> &getFunction(jsi::Runtime &rt);
 
- public:
-  CoreFunction(JSRuntimeHelper *runtimeHelper, const jsi::Value &workletObject);
   template <typename... Args>
-  jsi::Value call(jsi::Runtime &rt, Args &&...args) {
-    return getFunction(rt)->call(rt, args...);
+  inline void runOnUIGuarded(const jsi::Value &function, Args &&...args) {
+    // We only use callGuard in debug mode, otherwise we call the provided
+    // function directly. CallGuard provides a way of capturing exceptions in
+    // JavaScript and propagating them to the main React Native thread such that
+    // they can be presented using RN's LogBox.
+    jsi::Runtime &rt = *uiRuntime_;
+#ifdef DEBUG
+    callGuard->call(rt, function, args...);
+#else
+    function.asObject(rt).asFunction(rt).call(rt, args...);
+#endif
   }
 };
 
@@ -106,9 +115,7 @@ class Shareable {
     RemoteFunctionType,
     HandleType,
     SynchronizedDataHolder,
-#ifdef RCT_NEW_ARCH_ENABLED
-    ShadowNode,
-#endif
+    HostObjectType,
   };
 
   explicit Shareable(ValueType valueType) : valueType_(valueType) {}
@@ -126,34 +133,57 @@ class Shareable {
   ValueType valueType_;
 };
 
-class RetainingShareable : public Shareable {
- protected:
-  std::shared_ptr<JSRuntimeHelper> runtimeHelper_;
-
-#if HAS_JS_WEAK_OBJECTS
-
+template <typename BaseClass>
+class RetainingShareable : virtual public BaseClass {
  private:
-  std::unique_ptr<jsi::WeakObject> remoteValue_;
-
- public:
-  jsi::Value getJSValue(jsi::Runtime &rt) final;
-
-  RetainingShareable(
-      const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
-      jsi::Runtime &rt,
-      ValueType valueType)
-      : Shareable(valueType), runtimeHelper_(runtimeHelper) {}
-
-  ~RetainingShareable();
-#else
+  std::shared_ptr<JSRuntimeHelper> runtimeHelper_;
+  std::unique_ptr<jsi::Value> remoteValue_;
 
  public:
+  template <typename... Args>
   RetainingShareable(
       const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
-      jsi::Runtime &rt,
-      ValueType valueType)
-      : Shareable(valueType), runtimeHelper_(runtimeHelper) {}
-#endif
+      Args &&...args)
+      : BaseClass(std::forward<Args>(args)...), runtimeHelper_(runtimeHelper) {}
+  jsi::Value getJSValue(jsi::Runtime &rt) {
+    if (runtimeHelper_->isRNRuntime(rt)) {
+      // TODO: it is suboptimal to generate new object every time getJS is
+      // called on host runtime – the objects we are generating already exists
+      // and we should possibly just grab a hold of such object and use it here
+      // instead of creating a new JS representation. As far as I understand the
+      // only case where it can be realistically called this way is when a
+      // shared value is created and then accessed on the same runtime
+      return BaseClass::toJSValue(rt);
+    } else if (remoteValue_ == nullptr) {
+      auto value = BaseClass::toJSValue(rt);
+      remoteValue_ = std::make_unique<jsi::Value>(rt, value);
+      return value;
+    }
+    return jsi::Value(rt, *remoteValue_);
+  }
+  ~RetainingShareable() {
+    if (runtimeHelper_->uiRuntimeDestroyed) {
+      // The below use of unique_ptr.release prevents the smart pointer from
+      // calling the destructor of the kept object. This effectively results in
+      // leaking some memory. We do this on purpose, as sometimes we would keep
+      // references to JSI objects past the lifetime of its runtime (e.g.,
+      // shared values references from the RN VM holds reference to JSI objects
+      // on the UI runtime). When the UI runtime is terminated, the orphaned JSI
+      // objects would crash the app when their destructors are called, because
+      // they call into a memory that's managed by the terminated runtime. We
+      // accept the tradeoff of leaking memory here, as it has a limited impact.
+      // This scenario can only occur when the React instance is torn down which
+      // happens in development mode during app reloads, or in production when
+      // the app is being shut down gracefully by the system. An alternative
+      // solution would require us to keep track of all JSI values that are in
+      // use which would require additional data structure and compute spent on
+      // bookkeeping that only for the sake of destroying the values in time
+      // before the runtime is terminated. Note that the underlying memory that
+      // jsi::Value refers to is managed by the VM and gets freed along with the
+      // runtime.
+      remoteValue_.release();
+    }
+  }
 };
 
 class ShareableJSRef : public jsi::HostObject {
@@ -195,12 +225,9 @@ std::shared_ptr<T> extractShareableOrThrow(
   return res;
 }
 
-class ShareableArray : public RetainingShareable {
+class ShareableArray : public Shareable {
  public:
-  ShareableArray(
-      const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
-      jsi::Runtime &rt,
-      const jsi::Array &array);
+  ShareableArray(jsi::Runtime &rt, const jsi::Array &array);
 
   jsi::Value toJSValue(jsi::Runtime &rt) override {
     auto size = data_.size();
@@ -215,12 +242,9 @@ class ShareableArray : public RetainingShareable {
   std::vector<std::shared_ptr<Shareable>> data_;
 };
 
-class ShareableObject : public RetainingShareable {
+class ShareableObject : public Shareable {
  public:
-  ShareableObject(
-      const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
-      jsi::Runtime &rt,
-      const jsi::Object &object);
+  ShareableObject(jsi::Runtime &rt, const jsi::Object &object);
   jsi::Value toJSValue(jsi::Runtime &rt) override {
     auto obj = jsi::Object(rt);
     for (size_t i = 0, size = data_.size(); i < size; i++) {
@@ -234,34 +258,31 @@ class ShareableObject : public RetainingShareable {
   std::vector<std::pair<std::string, std::shared_ptr<Shareable>>> data_;
 };
 
-#ifdef RCT_NEW_ARCH_ENABLED
-class ShareableShadowNodeWrapper : public Shareable {
- private:
-  react::ShadowNode::Shared shadowNode_;
-
+class ShareableHostObject : public Shareable {
  public:
-  ShareableShadowNodeWrapper(
+  ShareableHostObject(
       const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
       jsi::Runtime &rt,
-      const jsi::Object &wrapperObject)
-      : Shareable(ShadowNode) {
-    shadowNode_ =
-        wrapperObject.getHostObject<ShadowNodeWrapper>(rt)->shadowNode;
-  }
+      const std::shared_ptr<jsi::HostObject> &hostObject)
+      : Shareable(HostObjectType), hostObject_(hostObject) {}
   jsi::Value toJSValue(jsi::Runtime &rt) override {
-    return jsi::Object::createFromHostObject(
-        rt, std::make_shared<ShadowNodeWrapper>(shadowNode_));
+    return jsi::Object::createFromHostObject(rt, hostObject_);
   }
+
+ protected:
+  std::shared_ptr<jsi::HostObject> hostObject_;
 };
-#endif
 
 class ShareableWorklet : public ShareableObject {
+ private:
+  std::shared_ptr<JSRuntimeHelper> runtimeHelper_;
+
  public:
   ShareableWorklet(
       const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
       jsi::Runtime &rt,
       const jsi::Object &worklet)
-      : ShareableObject(runtimeHelper, rt, worklet) {
+      : ShareableObject(rt, worklet), runtimeHelper_(runtimeHelper) {
     valueType_ = WorkletType;
   }
   jsi::Value toJSValue(jsi::Runtime &rt) override {
@@ -271,18 +292,20 @@ class ShareableWorklet : public ShareableObject {
 };
 
 class ShareableRemoteFunction
-    : public RetainingShareable,
+    : public Shareable,
       public std::enable_shared_from_this<ShareableRemoteFunction> {
  private:
   jsi::Function function_;
+  std::shared_ptr<JSRuntimeHelper> runtimeHelper_;
 
  public:
   ShareableRemoteFunction(
       const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
       jsi::Runtime &rt,
       jsi::Function &&function)
-      : RetainingShareable(runtimeHelper, rt, RemoteFunctionType),
-        function_(std::move(function)) {}
+      : Shareable(RemoteFunctionType),
+        function_(std::move(function)),
+        runtimeHelper_(runtimeHelper) {}
   jsi::Value toJSValue(jsi::Runtime &rt) override {
     if (runtimeHelper_->isUIRuntime(rt)) {
 #ifdef DEBUG
@@ -311,8 +334,7 @@ class ShareableHandle : public Shareable {
       jsi::Runtime &rt,
       const jsi::Object &initializerObject)
       : Shareable(HandleType), runtimeHelper_(runtimeHelper) {
-    initializer_ =
-        std::make_unique<ShareableObject>(runtimeHelper, rt, initializerObject);
+    initializer_ = std::make_unique<ShareableObject>(rt, initializerObject);
   }
   ~ShareableHandle() {
     if (runtimeHelper_->uiRuntimeDestroyed) {
@@ -357,7 +379,7 @@ class ShareableSynchronizedDataHolder
   std::shared_ptr<Shareable> data_;
   std::shared_ptr<jsi::Value> uiValue_;
   std::shared_ptr<jsi::Value> rnValue_;
-  std::mutex dataAccessLock_;
+  std::mutex dataAccessMutex_; // Protects `data_`.
 
  public:
   ShareableSynchronizedDataHolder(
@@ -369,7 +391,7 @@ class ShareableSynchronizedDataHolder
         data_(extractShareableOrThrow(rt, initialValue)) {}
 
   jsi::Value get(jsi::Runtime &rt) {
-    std::unique_lock<std::mutex> read_lock(dataAccessLock_);
+    std::unique_lock<std::mutex> read_lock(dataAccessMutex_);
     if (runtimeHelper_->isUIRuntime(rt)) {
       if (uiValue_ == nullptr) {
         auto value = data_->getJSValue(rt);
@@ -390,7 +412,7 @@ class ShareableSynchronizedDataHolder
   }
 
   void set(jsi::Runtime &rt, const jsi::Value &data) {
-    std::unique_lock<std::mutex> write_lock(dataAccessLock_);
+    std::unique_lock<std::mutex> write_lock(dataAccessMutex_);
     data_ = extractShareableOrThrow(rt, data);
     uiValue_.reset();
     rnValue_.reset();
@@ -403,16 +425,14 @@ class ShareableSynchronizedDataHolder
 
 class ShareableString : public Shareable {
  public:
-  ShareableString(jsi::Runtime &rt, const jsi::String &string)
-      : Shareable(StringType) {
-    data = string.utf8(rt);
-  }
+  explicit ShareableString(const std::string &string)
+      : Shareable(StringType), data_(string) {}
   jsi::Value toJSValue(jsi::Runtime &rt) override {
-    return jsi::String::createFromUtf8(rt, data);
+    return jsi::String::createFromUtf8(rt, data_);
   }
 
  protected:
-  std::string data;
+  std::string data_;
 };
 
 class ShareableScalar : public Shareable {