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

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)
@@ -105,12 +58,58 @@ NativeReanimatedModule::NativeReanimatedModule(
           platformDepMethodsHolder.configurePropsFunction)
 #endif
 {
-  auto requestAnimationFrame = [=](FrameCallback callback) {
-    frameCallbacks.push_back(callback);
+  auto requestAnimationFrame = [=](jsi::Runtime &rt, const jsi::Value &fn) {
+    auto jsFunction = std::make_shared<jsi::Value>(rt, fn);
+    frameCallbacks.push_back([=](double timestamp) {
+      runtimeHelper->runOnUIGuarded(*jsFunction, jsi::Value(timestamp));
+    });
     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 +150,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 +177,111 @@ NativeReanimatedModule::NativeReanimatedModule(
 
 void NativeReanimatedModule::installCoreFunctions(
     jsi::Runtime &rt,
-    const jsi::Value &valueSetter) {
-  this->valueSetter = ShareableValue::adapt(rt, valueSetter, this);
+    const jsi::Value &callGuard,
+    const jsi::Value &valueUnpacker) {
+  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->callGuard =
+      std::make_unique<CoreFunction>(runtimeHelper.get(), callGuard);
+  runtimeHelper->valueUnpacker =
+      std::make_unique<CoreFunction>(runtimeHelper.get(), valueUnpacker);
+}
+
+NativeReanimatedModule::~NativeReanimatedModule() {
+  if (runtimeHelper) {
+    runtimeHelper->callGuard = nullptr;
+    runtimeHelper->valueUnpacker = nullptr;
+    // event handler registry and frame callbacks store some JSI values from UI
+    // runtime, so they have to go away before we tear down the runtime
+    eventHandlerRegistry.reset();
+    frameCallbacks.clear();
+    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");
+  scheduler->scheduleOnUI([=] {
+    jsi::Runtime &rt = *runtimeHelper->uiRuntime();
+    auto workletValue = shareableWorklet->getJSValue(rt);
+    runtimeHelper->runOnUIGuarded(workletValue);
+  });
 }
 
-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 +292,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 +369,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 +391,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 +421,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 +436,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 +661,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(

package/Common/cpp/NativeModules/NativeReanimatedModule.h

@@ -13,7 +13,7 @@
 
 #include "AnimatedSensorModule.h"
 #include "ErrorHandler.h"
-#include "LayoutAnimationsProxy.h"
+#include "LayoutAnimationsManager.h"
 #include "NativeReanimatedModuleSpec.h"
 #include "PlatformDepMethodsHolder.h"
 #include "RuntimeDecorator.h"
@@ -25,46 +25,48 @@ namespace reanimated {
 
 using FrameCallback = std::function<void(double)>;
 
-class ShareableValue;
-class MutableValue;
-class MapperRegistry;
 class EventHandlerRegistry;
 
 class NativeReanimatedModule : public NativeReanimatedModuleSpec,
                                public RuntimeManager {
-  friend ShareableValue;
-  friend MutableValue;
-
  public:
   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);
 
-  void installCoreFunctions(jsi::Runtime &rt, const jsi::Value &valueSetter)
-      override;
+  ~NativeReanimatedModule();
 
-  jsi::Value makeShareable(jsi::Runtime &rt, const jsi::Value &value) override;
-  jsi::Value makeMutable(jsi::Runtime &rt, const jsi::Value &value) override;
-  jsi::Value makeRemote(jsi::Runtime &rt, const jsi::Value &value) override;
+  std::shared_ptr<JSRuntimeHelper> runtimeHelper;
 
-  jsi::Value startMapper(
+  void installCoreFunctions(
       jsi::Runtime &rt,
-      const jsi::Value &worklet,
-      const jsi::Value &inputs,
-      const jsi::Value &outputs,
-      const jsi::Value &updater,
-      const jsi::Value &viewDescriptors) override;
-  void stopMapper(jsi::Runtime &rt, const jsi::Value &mapperId) override;
+      const jsi::Value &callGuard,
+      const jsi::Value &valueUnpacker) override;
+
+  jsi::Value makeShareableClone(jsi::Runtime &rt, const jsi::Value &value)
+      override;
+
+  jsi::Value makeSynchronizedDataHolder(
+      jsi::Runtime &rt,
+      const jsi::Value &initialShareable) override;
+  jsi::Value getDataSynchronously(
+      jsi::Runtime &rt,
+      const jsi::Value &synchronizedDataHolderRef) override;
+  void updateDataSynchronously(
+      jsi::Runtime &rt,
+      const jsi::Value &synchronizedDataHolderRef,
+      const jsi::Value &newData);
+
+  void scheduleOnUI(jsi::Runtime &rt, const jsi::Value &worklet) override;
 
   jsi::Value registerEventHandler(
       jsi::Runtime &rt,
@@ -86,6 +88,11 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
       jsi::Runtime &rt,
       const jsi::Value &uiProps,
       const jsi::Value &nativeProps) override;
+  jsi::Value configureLayoutAnimation(
+      jsi::Runtime &rt,
+      const jsi::Value &viewTag,
+      const jsi::Value &type,
+      const jsi::Value &config) override;
 
   void onRender(double timestampMs);
 #ifdef RCT_NEW_ARCH_ENABLED
@@ -144,23 +151,17 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
       jsi::Runtime &rt,
       const jsi::Value &listenerId) override;
 
-  jsi::Value configureLayoutAnimation(
-      jsi::Runtime &rt,
-      const jsi::Value &viewTag,
-      const jsi::Value &type,
-      const jsi::Value &config,
-      const jsi::Value &viewSharedValue) override;
+  inline LayoutAnimationsManager &layoutAnimationsManager() {
+    return layoutAnimationsManager_;
+  }
 
  private:
 #ifdef RCT_NEW_ARCH_ENABLED
   bool isThereAnyLayoutProp(jsi::Runtime &rt, const jsi::Value &props);
 #endif // RCT_NEW_ARCH_ENABLED
 
-  std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy_;
-  std::shared_ptr<MapperRegistry> mapperRegistry;
-  std::shared_ptr<EventHandlerRegistry> eventHandlerRegistry;
+  std::unique_ptr<EventHandlerRegistry> eventHandlerRegistry;
   std::function<void(FrameCallback &, jsi::Runtime &)> requestRender;
-  std::shared_ptr<jsi::Value> dummyEvent;
   std::vector<FrameCallback> frameCallbacks;
   bool renderRequested = false;
   std::function<jsi::Value(jsi::Runtime &, const int, const jsi::String &)>
@@ -187,6 +188,7 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
 #endif
 
   std::unordered_set<std::string> nativePropNames_; // filled by configureProps
+  LayoutAnimationsManager layoutAnimationsManager_;
 
   KeyboardEventSubscribeFunction subscribeForKeyboardEventsFunction;
   KeyboardEventUnsubscribeFunction unsubscribeFromKeyboardEventsFunction;