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

package/Common/cpp/AnimatedSensor/AnimatedSensorModule.cpp

@@ -1,19 +1,17 @@
 #include "AnimatedSensorModule.h"
-#include "MutableValue.h"
-#include "ValueWrapper.h"
 
 #include <memory>
 #include <utility>
 
+#include "Shareables.h"
+
 namespace reanimated {
 
 AnimatedSensorModule::AnimatedSensorModule(
-    const PlatformDepMethodsHolder &platformDepMethodsHolder,
-    RuntimeManager *runtimeManager)
+    const PlatformDepMethodsHolder &platformDepMethodsHolder)
     : platformRegisterSensorFunction_(platformDepMethodsHolder.registerSensor),
       platformUnregisterSensorFunction_(
-          platformDepMethodsHolder.unregisterSensor),
-      runtimeManager_(runtimeManager) {}
+          platformDepMethodsHolder.unregisterSensor) {}
 
 AnimatedSensorModule::~AnimatedSensorModule() {
   // It is called during app reload because app reload doesn't call hooks
@@ -25,41 +23,38 @@ AnimatedSensorModule::~AnimatedSensorModule() {
 
 jsi::Value AnimatedSensorModule::registerSensor(
     jsi::Runtime &rt,
-    const jsi::Value &sensorType,
+    const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
+    const jsi::Value &sensorTypeValue,
     const jsi::Value &interval,
-    const jsi::Value &sensorDataContainer) {
-  std::shared_ptr<ShareableValue> sensorsData = ShareableValue::adapt(
-      rt, sensorDataContainer.getObject(rt), runtimeManager_);
-  auto &mutableObject =
-      ValueWrapper::asMutableValue(sensorsData->valueContainer);
+    const jsi::Value &sensorDataHandler) {
+  SensorType sensorType = static_cast<SensorType>(sensorTypeValue.asNumber());
 
-  std::function<void(double[])> setter;
-  if (sensorType.asNumber() == SensorType::ROTATION_VECTOR) {
-    setter = [&, mutableObject](double newValues[]) {
-      jsi::Runtime &runtime = *runtimeManager_->runtime.get();
-      jsi::Object value(runtime);
-      value.setProperty(runtime, "qx", newValues[0]);
-      value.setProperty(runtime, "qy", newValues[1]);
-      value.setProperty(runtime, "qz", newValues[2]);
-      value.setProperty(runtime, "qw", newValues[3]);
-      value.setProperty(runtime, "yaw", newValues[4]);
-      value.setProperty(runtime, "pitch", newValues[5]);
-      value.setProperty(runtime, "roll", newValues[6]);
-      mutableObject->setValue(runtime, std::move(value));
-    };
-  } else {
-    setter = [&, mutableObject](double newValues[]) {
-      jsi::Runtime &runtime = *runtimeManager_->runtime.get();
-      jsi::Object value(runtime);
-      value.setProperty(runtime, "x", newValues[0]);
-      value.setProperty(runtime, "y", newValues[1]);
-      value.setProperty(runtime, "z", newValues[2]);
-      mutableObject->setValue(runtime, std::move(value));
-    };
-  }
+  auto shareableHandler = extractShareableOrThrow(rt, sensorDataHandler);
+  auto uiRuntime = runtimeHelper->uiRuntime();
 
   int sensorId = platformRegisterSensorFunction_(
-      sensorType.asNumber(), interval.asNumber(), setter);
+      sensorType, interval.asNumber(), [=](double newValues[]) {
+        jsi::Runtime &rt = *uiRuntime;
+        auto handler =
+            shareableHandler->getJSValue(rt).asObject(rt).asFunction(rt);
+        if (sensorType == SensorType::ROTATION_VECTOR) {
+          jsi::Object value(rt);
+          value.setProperty(rt, "qx", newValues[0]);
+          value.setProperty(rt, "qy", newValues[1]);
+          value.setProperty(rt, "qz", newValues[2]);
+          value.setProperty(rt, "qw", newValues[3]);
+          value.setProperty(rt, "yaw", newValues[4]);
+          value.setProperty(rt, "pitch", newValues[5]);
+          value.setProperty(rt, "roll", newValues[6]);
+          handler.call(rt, value);
+        } else {
+          jsi::Object value(rt);
+          value.setProperty(rt, "x", newValues[0]);
+          value.setProperty(rt, "y", newValues[1]);
+          value.setProperty(rt, "z", newValues[2]);
+          handler.call(rt, value);
+        }
+      });
   if (sensorId != -1) {
     sensorsIds_.insert(sensorId);
   }

package/Common/cpp/AnimatedSensor/AnimatedSensorModule.h

@@ -1,10 +1,12 @@
 #pragma once
 
 #include <jsi/jsi.h>
+#include <memory>
 #include <unordered_set>
 
 #include "PlatformDepMethodsHolder.h"
 #include "RuntimeManager.h"
+#include "Shareables.h"
 
 namespace reanimated {
 
@@ -22,16 +24,15 @@ class AnimatedSensorModule {
   std::unordered_set<int> sensorsIds_;
   RegisterSensorFunction platformRegisterSensorFunction_;
   UnregisterSensorFunction platformUnregisterSensorFunction_;
-  RuntimeManager *runtimeManager_;
 
  public:
   AnimatedSensorModule(
-      const PlatformDepMethodsHolder &platformDepMethodsHolder,
-      RuntimeManager *runtimeManager);
+      const PlatformDepMethodsHolder &platformDepMethodsHolder);
   ~AnimatedSensorModule();
 
   jsi::Value registerSensor(
       jsi::Runtime &rt,
+      const std::shared_ptr<JSRuntimeHelper> &runtimeHelper,
       const jsi::Value &sensorType,
       const jsi::Value &interval,
       const jsi::Value &sensorDataContainer);

package/Common/cpp/LayoutAnimations/LayoutAnimationsManager.cpp

@@ -0,0 +1,76 @@
+#include "LayoutAnimationsManager.h"
+#include "Shareables.h"
+
+#include <utility>
+
+namespace reanimated {
+
+void LayoutAnimationsManager::configureAnimation(
+    int tag,
+    const std::string &type,
+    std::shared_ptr<Shareable> config) {
+  auto lock = std::unique_lock<std::mutex>(animationsMutex_);
+  if (type == "entering") {
+    enteringAnimations_[tag] = config;
+  } else if (type == "exiting") {
+    exitingAnimations_[tag] = config;
+  } else if (type == "layout") {
+    layoutAnimations_[tag] = config;
+  }
+}
+
+bool LayoutAnimationsManager::hasLayoutAnimation(
+    int tag,
+    const std::string &type) {
+  auto lock = std::unique_lock<std::mutex>(animationsMutex_);
+  if (type == "entering") {
+    return enteringAnimations_.find(tag) != enteringAnimations_.end();
+  } else if (type == "exiting") {
+    return exitingAnimations_.find(tag) != exitingAnimations_.end();
+  } else if (type == "layout") {
+    return layoutAnimations_.find(tag) != layoutAnimations_.end();
+  }
+  return false;
+}
+
+void LayoutAnimationsManager::clearLayoutAnimationConfig(int tag) {
+  auto lock = std::unique_lock<std::mutex>(animationsMutex_);
+  enteringAnimations_.erase(tag);
+  exitingAnimations_.erase(tag);
+  layoutAnimations_.erase(tag);
+}
+
+void LayoutAnimationsManager::startLayoutAnimation(
+    jsi::Runtime &rt,
+    int tag,
+    const std::string &type,
+    const jsi::Object &values) {
+  std::shared_ptr<Shareable> config, viewShareable;
+  {
+    auto lock = std::unique_lock<std::mutex>(animationsMutex_);
+    if (type == "entering") {
+      config = enteringAnimations_[tag];
+    } else if (type == "exiting") {
+      config = exitingAnimations_[tag];
+    } else if (type == "layout") {
+      config = layoutAnimations_[tag];
+    }
+  }
+
+  // TODO: cache the following!!
+  jsi::Value layoutAnimationRepositoryAsValue =
+      rt.global()
+          .getPropertyAsObject(rt, "global")
+          .getProperty(rt, "LayoutAnimationsManager");
+  jsi::Function startAnimationForTag =
+      layoutAnimationRepositoryAsValue.getObject(rt).getPropertyAsFunction(
+          rt, "start");
+  startAnimationForTag.call(
+      rt,
+      jsi::Value(tag),
+      jsi::String::createFromAscii(rt, type),
+      values,
+      config->getJSValue(rt));
+}
+
+} // namespace reanimated

package/Common/cpp/LayoutAnimations/LayoutAnimationsManager.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "ErrorHandler.h"
+#include "Shareables.h"
+
+#include <jsi/jsi.h>
+#include <stdio.h>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+namespace reanimated {
+
+using namespace facebook;
+
+class LayoutAnimationsManager {
+ public:
+  void configureAnimation(
+      int tag,
+      const std::string &type,
+      std::shared_ptr<Shareable> config);
+  bool hasLayoutAnimation(int tag, const std::string &type);
+  void startLayoutAnimation(
+      jsi::Runtime &rt,
+      int tag,
+      const std::string &type,
+      const jsi::Object &values);
+  void clearLayoutAnimationConfig(int tag);
+
+ private:
+  std::unordered_map<int, std::shared_ptr<Shareable>> enteringAnimations_;
+  std::unordered_map<int, std::shared_ptr<Shareable>> exitingAnimations_;
+  std::unordered_map<int, std::shared_ptr<Shareable>> layoutAnimations_;
+  mutable std::mutex
+      animationsMutex_; // Protects `enteringAnimations_`, `exitingAnimations_`,
+                        // `layoutAnimations_` and `viewSharedValues_`.
+};
+
+} // namespace reanimated

package/Common/cpp/NativeModules/NativeReanimatedModule.cpp

@@ -19,84 +19,37 @@
 
 #include "EventHandlerRegistry.h"
 #include "FeaturesConfig.h"
-#include "FrozenObject.h"
-#include "JSIStoreValueUser.h"
-#include "Mapper.h"
-#include "MapperRegistry.h"
-#include "MutableValue.h"
 #include "ReanimatedHiddenHeaders.h"
 #include "RuntimeDecorator.h"
-#include "ShareableValue.h"
+#include "Shareables.h"
 #include "WorkletEventHandler.h"
 
 using namespace facebook;
 
 namespace reanimated {
 
-void extractMutables(
-    jsi::Runtime &rt,
-    std::shared_ptr<ShareableValue> sv,
-    std::vector<std::shared_ptr<MutableValue>> &res) {
-  switch (sv->type) {
-    case ValueType::MutableValueType: {
-      auto &mutableValue = ValueWrapper::asMutableValue(sv->valueContainer);
-      res.push_back(mutableValue);
-      break;
-    }
-    case ValueType::FrozenArrayType:
-      for (auto &it : ValueWrapper::asFrozenArray(sv->valueContainer)) {
-        extractMutables(rt, it, res);
-      }
-      break;
-    case ValueType::RemoteObjectType:
-    case ValueType::FrozenObjectType:
-      for (auto &it : ValueWrapper::asFrozenObject(sv->valueContainer)->map) {
-        extractMutables(rt, it.second, res);
-      }
-      break;
-    default:
-      break;
-  }
-}
-
-std::vector<std::shared_ptr<MutableValue>> extractMutablesFromArray(
-    jsi::Runtime &rt,
-    const jsi::Array &array,
-    NativeReanimatedModule *module) {
-  std::vector<std::shared_ptr<MutableValue>> res;
-  for (size_t i = 0, size = array.size(rt); i < size; i++) {
-    auto shareable =
-        ShareableValue::adapt(rt, array.getValueAtIndex(rt, i), module);
-    extractMutables(rt, shareable, res);
-  }
-  return res;
-}
-
 NativeReanimatedModule::NativeReanimatedModule(
-    std::shared_ptr<CallInvoker> jsInvoker,
-    std::shared_ptr<Scheduler> scheduler,
-    std::shared_ptr<jsi::Runtime> rt,
-    std::shared_ptr<ErrorHandler> errorHandler,
+    const std::shared_ptr<CallInvoker> &jsInvoker,
+    const std::shared_ptr<Scheduler> &scheduler,
+    const std::shared_ptr<jsi::Runtime> &rt,
+    const std::shared_ptr<ErrorHandler> &errorHandler,
 #ifdef RCT_NEW_ARCH_ENABLED
 // nothing
 #else
     std::function<jsi::Value(jsi::Runtime &, const int, const jsi::String &)>
         propObtainer,
 #endif
-    std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy,
     PlatformDepMethodsHolder platformDepMethodsHolder)
     : NativeReanimatedModuleSpec(jsInvoker),
       RuntimeManager(rt, errorHandler, scheduler, RuntimeType::UI),
-      layoutAnimationsProxy_(layoutAnimationsProxy),
-      mapperRegistry(std::make_shared<MapperRegistry>()),
-      eventHandlerRegistry(std::make_shared<EventHandlerRegistry>()),
+      eventHandlerRegistry(std::make_unique<EventHandlerRegistry>()),
       requestRender(platformDepMethodsHolder.requestRender),
 #ifdef RCT_NEW_ARCH_ENABLED
 // nothing
 #else
       propObtainer(propObtainer),
 #endif
-      animatedSensorModule(platformDepMethodsHolder, this),
+      animatedSensorModule(platformDepMethodsHolder),
 #ifdef RCT_NEW_ARCH_ENABLED
       synchronouslyUpdateUIPropsFunction(
           platformDepMethodsHolder.synchronouslyUpdateUIPropsFunction)
@@ -110,7 +63,50 @@ NativeReanimatedModule::NativeReanimatedModule(
     maybeRequestRender();
   };
 
-  this->layoutAnimationsProxy_ = layoutAnimationsProxy;
+  auto scheduleOnJS = [this](
+                          jsi::Runtime &rt,
+                          const jsi::Value &remoteFun,
+                          const jsi::Value &argsValue) {
+    auto shareableRemoteFun = extractShareableOrThrow<ShareableRemoteFunction>(
+        rt,
+        remoteFun,
+        "Incompatible object passed to scheduleOnJS. It is only allowed to schedule functions defined on the React Native JS runtime this way.");
+    auto shareableArgs = argsValue.isUndefined()
+        ? nullptr
+        : extractShareableOrThrow(rt, argsValue);
+    auto jsRuntime = this->runtimeHelper->rnRuntime();
+    this->scheduler->scheduleOnJS([=] {
+      jsi::Runtime &rt = *jsRuntime;
+      auto remoteFun = shareableRemoteFun->getJSValue(rt);
+      if (shareableArgs == nullptr) {
+        // fast path for remote function w/o arguments
+        remoteFun.asObject(rt).asFunction(rt).call(rt);
+      } else {
+        auto argsArray = shareableArgs->getJSValue(rt).asObject(rt).asArray(rt);
+        auto argsSize = argsArray.size(rt);
+        // number of arguments is typically relatively small so it is ok to
+        // to use VLAs here, hence disabling the lint rule
+        jsi::Value args[argsSize]; // NOLINT(runtime/arrays)
+        for (size_t i = 0; i < argsSize; i++) {
+          args[i] = argsArray.getValueAtIndex(rt, i);
+        }
+        remoteFun.asObject(rt).asFunction(rt).call(rt, args, argsSize);
+      }
+    });
+  };
+
+  auto makeShareableClone = [this](jsi::Runtime &rt, const jsi::Value &value) {
+    return this->makeShareableClone(rt, value);
+  };
+
+  auto updateDataSynchronously =
+      [this](
+          jsi::Runtime &rt,
+          const jsi::Value &synchronizedDataHolderRef,
+          const jsi::Value &newData) {
+        return this->updateDataSynchronously(
+            rt, synchronizedDataHolderRef, newData);
+      };
 
 #ifdef RCT_NEW_ARCH_ENABLED
   auto updateProps = [this](
@@ -151,11 +147,15 @@ NativeReanimatedModule::NativeReanimatedModule(
       platformDepMethodsHolder.scrollToFunction,
 #endif
       requestAnimationFrame,
+      scheduleOnJS,
+      makeShareableClone,
+      updateDataSynchronously,
       platformDepMethodsHolder.getCurrentTime,
       platformDepMethodsHolder.registerSensor,
       platformDepMethodsHolder.unregisterSensor,
       platformDepMethodsHolder.setGestureStateFunction,
-      layoutAnimationsProxy);
+      platformDepMethodsHolder.progressLayoutAnimation,
+      platformDepMethodsHolder.endLayoutAnimation);
   onRenderCallback = [this](double timestampMs) {
     this->renderRequested = false;
     this->onRender(timestampMs);
@@ -174,87 +174,109 @@ NativeReanimatedModule::NativeReanimatedModule(
 
 void NativeReanimatedModule::installCoreFunctions(
     jsi::Runtime &rt,
-    const jsi::Value &valueSetter) {
-  this->valueSetter = ShareableValue::adapt(rt, valueSetter, this);
+    const jsi::Value &valueUnpacker,
+    const jsi::Value &layoutAnimationStartFunction) {
+  if (!runtimeHelper) {
+    // initialize runtimeHelper here if not already present. We expect only one
+    // instace of the helper to exists.
+    runtimeHelper =
+        std::make_shared<JSRuntimeHelper>(&rt, this->runtime.get(), scheduler);
+  }
+  runtimeHelper->valueUnpacker =
+      std::make_shared<CoreFunction>(runtimeHelper.get(), valueUnpacker);
+}
+
+NativeReanimatedModule::~NativeReanimatedModule() {
+  if (runtimeHelper) {
+    runtimeHelper->valueUnpacker = nullptr;
+    // event handler registry stores some JSI values from UI runtime, so it has
+    // to go away before we tear down the runtime
+    eventHandlerRegistry.reset();
+    runtime.reset();
+    // make sure uiRuntimeDestroyed is set after the runtime is deallocated
+    runtimeHelper->uiRuntimeDestroyed = true;
+  }
 }
 
-jsi::Value NativeReanimatedModule::makeShareable(
+void NativeReanimatedModule::scheduleOnUI(
     jsi::Runtime &rt,
-    const jsi::Value &value) {
-  return ShareableValue::adapt(rt, value, this)->getValue(rt);
+    const jsi::Value &worklet) {
+  auto shareableWorklet = extractShareableOrThrow(rt, worklet);
+  assert(
+      shareableWorklet->valueType() == Shareable::WorkletType &&
+      "only worklets can be scheduled to run on UI");
+  auto uiRuntime = runtimeHelper->uiRuntime();
+  frameCallbacks.push_back([=](double timestamp) {
+    jsi::Runtime &rt = *uiRuntime;
+    auto workletValue = shareableWorklet->getJSValue(rt);
+    workletValue.asObject(rt).asFunction(rt).call(rt);
+  });
+  maybeRequestRender();
 }
 
-jsi::Value NativeReanimatedModule::makeMutable(
+jsi::Value NativeReanimatedModule::makeSynchronizedDataHolder(
     jsi::Runtime &rt,
-    const jsi::Value &value) {
-  return ShareableValue::adapt(rt, value, this, ValueType::MutableValueType)
-      ->getValue(rt);
+    const jsi::Value &initialShareable) {
+  auto dataHolder = std::make_shared<ShareableSynchronizedDataHolder>(
+      runtimeHelper, rt, initialShareable);
+  return dataHolder->getJSValue(rt);
 }
 
-jsi::Value NativeReanimatedModule::makeRemote(
+void NativeReanimatedModule::updateDataSynchronously(
     jsi::Runtime &rt,
-    const jsi::Value &value) {
-  return ShareableValue::adapt(rt, value, this, ValueType::RemoteObjectType)
-      ->getValue(rt);
+    const jsi::Value &synchronizedDataHolderRef,
+    const jsi::Value &newData) {
+  auto dataHolder = extractShareableOrThrow<ShareableSynchronizedDataHolder>(
+      rt, synchronizedDataHolderRef);
+  dataHolder->set(rt, newData);
 }
 
-jsi::Value NativeReanimatedModule::startMapper(
+jsi::Value NativeReanimatedModule::getDataSynchronously(
     jsi::Runtime &rt,
-    const jsi::Value &worklet,
-    const jsi::Value &inputs,
-    const jsi::Value &outputs,
-    const jsi::Value &updater,
-    const jsi::Value &viewDescriptors) {
-  static unsigned long MAPPER_ID = 1;
-
-  unsigned long newMapperId = MAPPER_ID++;
-  auto mapperShareable = ShareableValue::adapt(rt, worklet, this);
-  auto inputMutables =
-      extractMutablesFromArray(rt, inputs.asObject(rt).asArray(rt), this);
-  auto outputMutables =
-      extractMutablesFromArray(rt, outputs.asObject(rt).asArray(rt), this);
-
-  int optimalizationLvl = 0;
-  auto optimalization =
-      updater.asObject(rt).getProperty(rt, "__optimalization");
-  if (optimalization.isNumber()) {
-    optimalizationLvl = optimalization.asNumber();
-  }
-  auto updaterSV = ShareableValue::adapt(rt, updater, this);
-  auto viewDescriptorsSV = ShareableValue::adapt(rt, viewDescriptors, this);
-
-  scheduler->scheduleOnUI([=] {
-    auto mapperFunction =
-        mapperShareable->getValue(*runtime).asObject(*runtime).asFunction(
-            *runtime);
-    std::shared_ptr<jsi::Function> mapperFunctionPointer =
-        std::make_shared<jsi::Function>(std::move(mapperFunction));
-
-    std::shared_ptr<Mapper> mapperPointer = std::make_shared<Mapper>(
-        this,
-        newMapperId,
-        mapperFunctionPointer,
-        inputMutables,
-        outputMutables);
-    if (optimalizationLvl > 0) {
-      mapperPointer->enableFastMode(
-          optimalizationLvl, updaterSV, viewDescriptorsSV);
-    }
-    mapperRegistry->startMapper(mapperPointer);
-    maybeRequestRender();
-  });
-
-  return jsi::Value(static_cast<double>(newMapperId));
+    const jsi::Value &synchronizedDataHolderRef) {
+  auto dataHolder = extractShareableOrThrow<ShareableSynchronizedDataHolder>(
+      rt, synchronizedDataHolderRef);
+  return dataHolder->get(rt);
 }
 
-void NativeReanimatedModule::stopMapper(
+jsi::Value NativeReanimatedModule::makeShareableClone(
     jsi::Runtime &rt,
-    const jsi::Value &mapperId) {
-  unsigned long id = mapperId.asNumber();
-  scheduler->scheduleOnUI([=] {
-    mapperRegistry->stopMapper(id);
-    maybeRequestRender();
-  });
+    const jsi::Value &value) {
+  std::shared_ptr<Shareable> shareable;
+  if (value.isObject()) {
+    auto object = value.asObject(rt);
+    if (!object.getProperty(rt, "__workletHash").isUndefined()) {
+      shareable = std::make_shared<ShareableWorklet>(runtimeHelper, rt, object);
+    } else if (!object.getProperty(rt, "__init").isUndefined()) {
+      shareable = std::make_shared<ShareableHandle>(runtimeHelper, rt, object);
+    } else if (object.isFunction(rt)) {
+      shareable = std::make_shared<ShareableRemoteFunction>(
+          runtimeHelper, rt, object.asFunction(rt));
+    } else if (object.isArray(rt)) {
+      shareable = std::make_shared<ShareableArray>(
+          runtimeHelper, rt, object.asArray(rt));
+#ifdef RCT_NEW_ARCH_ENABLED
+    } else if (object.isHostObject<ShadowNodeWrapper>(rt)) {
+      shareable = std::make_shared<ShareableShadowNodeWrapper>(
+          runtimeHelper, rt, object);
+#endif
+    } else {
+      shareable = std::make_shared<ShareableObject>(runtimeHelper, rt, object);
+    }
+  } else if (value.isString()) {
+    shareable = std::make_shared<ShareableString>(rt, value.asString(rt));
+  } else if (value.isUndefined()) {
+    shareable = std::make_shared<ShareableScalar>();
+  } else if (value.isNull()) {
+    shareable = std::make_shared<ShareableScalar>(nullptr);
+  } else if (value.isBool()) {
+    shareable = std::make_shared<ShareableScalar>(value.getBool());
+  } else if (value.isNumber()) {
+    shareable = std::make_shared<ShareableScalar>(value.getNumber());
+  } else {
+    throw std::runtime_error("attempted to convert an unsupported value type");
+  }
+  return ShareableJSRef::newHostObject(rt, shareable);
 }
 
 jsi::Value NativeReanimatedModule::registerEventHandler(
@@ -265,12 +287,12 @@ jsi::Value NativeReanimatedModule::registerEventHandler(
 
   unsigned long newRegistrationId = EVENT_HANDLER_ID++;
   auto eventName = eventHash.asString(rt).utf8(rt);
-  auto handlerShareable = ShareableValue::adapt(rt, worklet, this);
+  auto handlerShareable = extractShareableOrThrow(rt, worklet);
 
   scheduler->scheduleOnUI([=] {
+    jsi::Runtime &rt = *runtimeHelper->uiRuntime();
     auto handlerFunction =
-        handlerShareable->getValue(*runtime).asObject(*runtime).asFunction(
-            *runtime);
+        handlerShareable->getJSValue(rt).asObject(rt).asFunction(rt);
     auto handler = std::make_shared<WorkletEventHandler>(
         newRegistrationId, eventName, std::move(handlerFunction));
     eventHandlerRegistry->registerEventHandler(handler);
@@ -342,13 +364,11 @@ jsi::Value NativeReanimatedModule::configureLayoutAnimation(
     jsi::Runtime &rt,
     const jsi::Value &viewTag,
     const jsi::Value &type,
-    const jsi::Value &config,
-    const jsi::Value &viewSharedValue) {
-  layoutAnimationsProxy_->configureAnimation(
+    const jsi::Value &config) {
+  layoutAnimationsManager_.configureAnimation(
       viewTag.asNumber(),
       type.asString(rt).utf8(rt),
-      ShareableValue::adapt(rt, config, this),
-      ShareableValue::adapt(rt, viewSharedValue, this));
+      extractShareableOrThrow(rt, config));
   return jsi::Value::undefined();
 }
 
@@ -366,10 +386,6 @@ void NativeReanimatedModule::onEvent(
 #else
     eventHandlerRegistry->processEvent(*runtime, eventName, eventAsString);
 #endif
-    mapperRegistry->execute(*runtime);
-    if (mapperRegistry->needRunOnRender()) {
-      maybeRequestRender();
-    }
   } catch (std::exception &e) {
     std::string str = e.what();
     this->errorHandler->setError(str);
@@ -400,11 +416,6 @@ void NativeReanimatedModule::onRender(double timestampMs) {
     for (auto &callback : callbacks) {
       callback(timestampMs);
     }
-    mapperRegistry->execute(*runtime);
-
-    if (mapperRegistry->needRunOnRender()) {
-      maybeRequestRender();
-    }
   } catch (std::exception &e) {
     std::string str = e.what();
     this->errorHandler->setError(str);
@@ -420,9 +431,9 @@ jsi::Value NativeReanimatedModule::registerSensor(
     jsi::Runtime &rt,
     const jsi::Value &sensorType,
     const jsi::Value &interval,
-    const jsi::Value &sensorDataContainer) {
+    const jsi::Value &sensorDataHandler) {
   return animatedSensorModule.registerSensor(
-      rt, sensorType, interval, sensorDataContainer);
+      rt, runtimeHelper, sensorType, interval, sensorDataHandler);
 }
 
 void NativeReanimatedModule::unregisterSensor(
@@ -645,30 +656,15 @@ void NativeReanimatedModule::setNewestShadowNodesRegistry(
 
 jsi::Value NativeReanimatedModule::subscribeForKeyboardEvents(
     jsi::Runtime &rt,
-    const jsi::Value &keyboardEventContainer) {
-  jsi::Object keyboardEventObj = keyboardEventContainer.getObject(rt);
-  std::unordered_map<std::string, std::shared_ptr<ShareableValue>>
-      sharedProperties;
-  std::shared_ptr<ShareableValue> keyboardStateShared = ShareableValue::adapt(
-      rt, keyboardEventObj.getProperty(rt, "state"), this);
-  std::shared_ptr<ShareableValue> heightShared = ShareableValue::adapt(
-      rt, keyboardEventObj.getProperty(rt, "height"), this);
-
-  auto keyboardEventDataUpdater =
-      [this, &rt, keyboardStateShared, heightShared](
-          int keyboardState, int height) {
-        auto &keyboardStateValue =
-            ValueWrapper::asMutableValue(keyboardStateShared->valueContainer);
-        keyboardStateValue->setValue(rt, jsi::Value(keyboardState));
-
-        auto &heightMutableValue =
-            ValueWrapper::asMutableValue(heightShared->valueContainer);
-        heightMutableValue->setValue(rt, jsi::Value(height));
-
-        this->mapperRegistry->execute(*this->runtime);
-      };
-
-  return subscribeForKeyboardEventsFunction(keyboardEventDataUpdater);
+    const jsi::Value &handlerWorklet) {
+  auto shareableHandler = extractShareableOrThrow(rt, handlerWorklet);
+  auto uiRuntime = runtimeHelper->uiRuntime();
+  return subscribeForKeyboardEventsFunction([=](int keyboardState, int height) {
+    jsi::Runtime &rt = *uiRuntime;
+    auto handler = shareableHandler->getJSValue(rt);
+    handler.asObject(rt).asFunction(rt).call(
+        rt, jsi::Value(keyboardState), jsi::Value(height));
+  });
 }
 
 void NativeReanimatedModule::unsubscribeFromKeyboardEvents(