react-native-reanimated 2.9.1 → 3.0.0-rc.2

package/Common/cpp/NativeModules/NativeReanimatedModule.cpp

@@ -1,7 +1,21 @@
 #include "NativeReanimatedModule.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <react/renderer/uimanager/UIManagerBinding.h>
+#include <react/renderer/uimanager/primitives.h>
+#endif
+
 #include <functional>
 #include <memory>
 #include <thread>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#include "FabricUtils.h"
+#include "NewestShadowNodesRegistry.h"
+#include "ReanimatedUIManagerBinding.h"
+#include "ShadowTreeCloner.h"
+#endif
+
 #include "EventHandlerRegistry.h"
 #include "FeaturesConfig.h"
 #include "FrozenObject.h"
@@ -62,8 +76,12 @@ NativeReanimatedModule::NativeReanimatedModule(
     std::shared_ptr<Scheduler> scheduler,
     std::shared_ptr<jsi::Runtime> rt,
     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),
@@ -71,10 +89,20 @@ NativeReanimatedModule::NativeReanimatedModule(
       mapperRegistry(std::make_shared<MapperRegistry>()),
       eventHandlerRegistry(std::make_shared<EventHandlerRegistry>()),
       requestRender(platformDepMethodsHolder.requestRender),
+#ifdef RCT_NEW_ARCH_ENABLED
+// nothing
+#else
       propObtainer(propObtainer),
+#endif
       animatedSensorModule(platformDepMethodsHolder, this),
+#ifdef RCT_NEW_ARCH_ENABLED
+      synchronouslyUpdateUIPropsFunction(
+          platformDepMethodsHolder.synchronouslyUpdateUIPropsFunction)
+#else
       configurePropsPlatformFunction(
-          platformDepMethodsHolder.configurePropsFunction) {
+          platformDepMethodsHolder.configurePropsFunction)
+#endif
+{
   auto requestAnimationFrame = [=](FrameCallback callback) {
     frameCallbacks.push_back(callback);
     maybeRequestRender();
@@ -82,12 +110,45 @@ NativeReanimatedModule::NativeReanimatedModule(
 
   this->layoutAnimationsProxy = layoutAnimationsProxy;
 
+#ifdef RCT_NEW_ARCH_ENABLED
+  auto updateProps = [this](
+                         jsi::Runtime &rt,
+                         const jsi::Value &shadowNodeValue,
+                         const jsi::Value &props) {
+    this->updateProps(rt, shadowNodeValue, props);
+  };
+
+  auto removeShadowNodeFromRegistry =
+      [this](jsi::Runtime &rt, const jsi::Value &shadowNodeValue) {
+        this->removeShadowNodeFromRegistry(rt, shadowNodeValue);
+      };
+
+  auto measure = [this](jsi::Runtime &rt, const jsi::Value &shadowNodeValue) {
+    return this->measure(rt, shadowNodeValue);
+  };
+
+  auto dispatchCommand = [this](
+                             jsi::Runtime &rt,
+                             const jsi::Value &shadowNodeValue,
+                             const jsi::Value &commandNameValue,
+                             const jsi::Value &argsValue) {
+    this->dispatchCommand(rt, shadowNodeValue, commandNameValue, argsValue);
+  };
+#endif
+
   RuntimeDecorator::decorateUIRuntime(
       *runtime,
-      platformDepMethodsHolder.updaterFunction,
-      requestAnimationFrame,
+#ifdef RCT_NEW_ARCH_ENABLED
+      updateProps,
+      measure,
+      removeShadowNodeFromRegistry,
+      dispatchCommand,
+#else
+      platformDepMethodsHolder.updatePropsFunction,
+      platformDepMethodsHolder.measureFunction,
       platformDepMethodsHolder.scrollToFunction,
-      platformDepMethodsHolder.measuringFunction,
+#endif
+      requestAnimationFrame,
       platformDepMethodsHolder.getCurrentTime,
       platformDepMethodsHolder.registerSensor,
       platformDepMethodsHolder.unregisterSensor,
@@ -97,7 +158,16 @@ NativeReanimatedModule::NativeReanimatedModule(
     this->renderRequested = false;
     this->onRender(timestampMs);
   };
-  updaterFunction = platformDepMethodsHolder.updaterFunction;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  // nothing
+#else
+  updatePropsFunction = platformDepMethodsHolder.updatePropsFunction;
+#endif
+  subscribeForKeyboardEventsFunction =
+      platformDepMethodsHolder.subscribeForKeyboardEvents;
+  unsubscribeFromKeyboardEventsFunction =
+      platformDepMethodsHolder.unsubscribeFromKeyboardEvents;
 }
 
 void NativeReanimatedModule::installCoreFunctions(
@@ -253,15 +323,33 @@ jsi::Value NativeReanimatedModule::configureProps(
     jsi::Runtime &rt,
     const jsi::Value &uiProps,
     const jsi::Value &nativeProps) {
+#ifdef RCT_NEW_ARCH_ENABLED
+  jsi::Array array = nativeProps.asObject(rt).asArray(rt);
+  for (int i = 0; i < array.size(rt); ++i) {
+    std::string name = array.getValueAtIndex(rt, i).asString(rt).utf8(rt);
+    nativePropNames_.insert(name);
+  }
+#else
   configurePropsPlatformFunction(rt, uiProps, nativeProps);
+#endif // RCT_NEW_ARCH_ENABLED
+
   return jsi::Value::undefined();
 }
 
 void NativeReanimatedModule::onEvent(
     std::string eventName,
-    std::string eventAsString) {
+#ifdef RCT_NEW_ARCH_ENABLED
+    jsi::Value &&payload
+#else
+    std::string eventAsString
+#endif
+    /**/) {
   try {
+#ifdef RCT_NEW_ARCH_ENABLED
+    eventHandlerRegistry->processEvent(*runtime, eventName, payload);
+#else
     eventHandlerRegistry->processEvent(*runtime, eventName, eventAsString);
+#endif
     mapperRegistry->execute(*runtime);
     if (mapperRegistry->needRunOnRender()) {
       maybeRequestRender();
@@ -327,4 +415,246 @@ void NativeReanimatedModule::unregisterSensor(
   animatedSensorModule.unregisterSensor(sensorId);
 }
 
+#ifdef RCT_NEW_ARCH_ENABLED
+bool NativeReanimatedModule::isThereAnyLayoutProp(
+    jsi::Runtime &rt,
+    const jsi::Value &props) {
+  const jsi::Array propNames = props.asObject(rt).getPropertyNames(rt);
+  for (size_t i = 0; i < propNames.size(rt); ++i) {
+    const std::string propName =
+        propNames.getValueAtIndex(rt, i).asString(rt).utf8(rt);
+    bool isLayoutProp =
+        nativePropNames_.find(propName) != nativePropNames_.end();
+    if (isLayoutProp) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool NativeReanimatedModule::handleEvent(
+    const std::string &eventName,
+    jsi::Value &&payload,
+    double currentTime) {
+  jsi::Runtime &rt = *runtime.get();
+  jsi::Object global = rt.global();
+  jsi::String eventTimestampName =
+      jsi::String::createFromAscii(rt, "_eventTimestamp");
+  global.setProperty(rt, eventTimestampName, currentTime);
+  onEvent(eventName, std::move(payload));
+  global.setProperty(rt, eventTimestampName, jsi::Value::undefined());
+
+  // TODO: return true if Reanimated successfully handled the event
+  // to avoid sending it to JavaScript
+  return false;
+}
+
+bool NativeReanimatedModule::handleRawEvent(
+    const RawEvent &rawEvent,
+    double currentTime) {
+  const EventTarget *eventTarget = rawEvent.eventTarget.get();
+  if (eventTarget == nullptr) {
+    // after app reload scrollview is unmounted and its content offset is set to
+    // 0 and view is thrown into recycle pool setting content offset triggers
+    // scroll event eventTarget is null though, because it's unmounting we can
+    // just ignore this event, because it's an event on unmounted component
+    return false;
+  }
+  const std::string &type = rawEvent.type;
+  const ValueFactory &payloadFactory = rawEvent.payloadFactory;
+
+  int tag = eventTarget->getTag();
+  std::string eventType = type;
+  if (eventType.rfind("top", 0) == 0) {
+    eventType = "on" + eventType.substr(3);
+  }
+  std::string eventName = std::to_string(tag) + eventType;
+  jsi::Runtime &rt = *runtime.get();
+  jsi::Value payload = payloadFactory(rt);
+
+  return handleEvent(eventName, std::move(payload), currentTime);
+}
+
+void NativeReanimatedModule::updateProps(
+    jsi::Runtime &rt,
+    const jsi::Value &shadowNodeValue,
+    const jsi::Value &props) {
+  ShadowNode::Shared shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
+
+  // TODO: support multiple surfaces
+  surfaceId_ = shadowNode->getSurfaceId();
+
+  if (isThereAnyLayoutProp(rt, props)) {
+    operationsInBatch_.emplace_back(
+        shadowNode, std::make_unique<jsi::Value>(rt, props));
+  } else {
+    // TODO: batch with layout props changes?
+    Tag tag = shadowNode->getTag();
+    synchronouslyUpdateUIPropsFunction(rt, tag, props);
+  }
+}
+
+void NativeReanimatedModule::performOperations() {
+  if (operationsInBatch_.empty()) {
+    return;
+  }
+
+  auto copiedOperationsQueue = std::move(operationsInBatch_);
+  operationsInBatch_ =
+      std::vector<std::pair<ShadowNode::Shared, std::unique_ptr<jsi::Value>>>();
+
+  auto copiedTagsToRemove = std::move(tagsToRemove_);
+  tagsToRemove_ = std::vector<Tag>();
+
+  react_native_assert(uiManager_ != nullptr);
+  const auto &shadowTreeRegistry = uiManager_->getShadowTreeRegistry();
+  jsi::Runtime &rt = *runtime.get();
+
+  shadowTreeRegistry.visit(surfaceId_, [&](ShadowTree const &shadowTree) {
+    shadowTree.commit([&](RootShadowNode const &oldRootShadowNode) {
+      auto rootNode = oldRootShadowNode.ShadowNode::clone(ShadowNodeFragment{});
+
+      ShadowTreeCloner shadowTreeCloner{
+          newestShadowNodesRegistry_, uiManager_, surfaceId_};
+
+      {
+        // lock once due to performance reasons
+        auto lock = newestShadowNodesRegistry_->createLock();
+
+        for (const auto &pair : copiedOperationsQueue) {
+          const ShadowNodeFamily &family = pair.first->getFamily();
+          react_native_assert(family.getSurfaceId() == surfaceId_);
+
+          auto newRootNode = shadowTreeCloner.cloneWithNewProps(
+              rootNode, family, RawProps(rt, *pair.second));
+
+          if (newRootNode == nullptr) {
+            // this happens when React removed the component but Reanimated
+            // still tries to animate it, let's skip update for this specific
+            // component
+            continue;
+          }
+          rootNode = newRootNode;
+        }
+
+        // remove ShadowNodes and its ancestors from NewestShadowNodesRegistry
+        for (auto tag : copiedTagsToRemove) {
+          newestShadowNodesRegistry_->remove(tag);
+        }
+      }
+
+      shadowTreeCloner.updateYogaChildren();
+
+      return std::static_pointer_cast<RootShadowNode>(rootNode);
+    });
+  });
+}
+
+void NativeReanimatedModule::removeShadowNodeFromRegistry(
+    jsi::Runtime &rt,
+    const jsi::Value &shadowNodeValue) {
+  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
+  tagsToRemove_.push_back(shadowNode->getTag());
+}
+
+void NativeReanimatedModule::dispatchCommand(
+    jsi::Runtime &rt,
+    const jsi::Value &shadowNodeValue,
+    const jsi::Value &commandNameValue,
+    const jsi::Value &argsValue) {
+  ShadowNode::Shared shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
+  std::string commandName = stringFromValue(rt, commandNameValue);
+  folly::dynamic args = commandArgsFromValue(rt, argsValue);
+
+  // TODO: use uiManager_->dispatchCommand once it's public
+  UIManager_dispatchCommand(uiManager_, shadowNode, commandName, args);
+}
+
+jsi::Value NativeReanimatedModule::measure(
+    jsi::Runtime &rt,
+    const jsi::Value &shadowNodeValue) {
+  // based on implementation from UIManagerBinding.cpp
+
+  auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
+  // TODO: use uiManager_->getRelativeLayoutMetrics once it's public
+  // auto layoutMetrics = uiManager_->getRelativeLayoutMetrics(
+  //     *shadowNode, nullptr, {/* .includeTransform = */ true});
+  auto layoutMetrics = UIManager_getRelativeLayoutMetrics(
+      uiManager_, *shadowNode, nullptr, {/* .includeTransform = */ true});
+
+  if (layoutMetrics == EmptyLayoutMetrics) {
+    return jsi::Value::undefined();
+  }
+  auto newestCloneOfShadowNode =
+      uiManager_->getNewestCloneOfShadowNode(*shadowNode);
+
+  auto layoutableShadowNode =
+      traitCast<LayoutableShadowNode const *>(newestCloneOfShadowNode.get());
+  facebook::react::Point originRelativeToParent = layoutableShadowNode
+      ? layoutableShadowNode->getLayoutMetrics().frame.origin
+      : facebook::react::Point();
+
+  auto frame = layoutMetrics.frame;
+
+  jsi::Object result(rt);
+  result.setProperty(
+      rt, "x", jsi::Value(static_cast<double>(originRelativeToParent.x)));
+  result.setProperty(
+      rt, "y", jsi::Value(static_cast<double>(originRelativeToParent.y)));
+  result.setProperty(
+      rt, "width", jsi::Value(static_cast<double>(frame.size.width)));
+  result.setProperty(
+      rt, "height", jsi::Value(static_cast<double>(frame.size.height)));
+  result.setProperty(
+      rt, "pageX", jsi::Value(static_cast<double>(frame.origin.x)));
+  result.setProperty(
+      rt, "pageY", jsi::Value(static_cast<double>(frame.origin.y)));
+  return result;
+}
+
+void NativeReanimatedModule::setUIManager(
+    std::shared_ptr<UIManager> uiManager) {
+  uiManager_ = uiManager;
+}
+
+void NativeReanimatedModule::setNewestShadowNodesRegistry(
+    std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry) {
+  newestShadowNodesRegistry_ = newestShadowNodesRegistry;
+}
+#endif // RCT_NEW_ARCH_ENABLED
+
+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);
+}
+
+void NativeReanimatedModule::unsubscribeFromKeyboardEvents(
+    jsi::Runtime &rt,
+    const jsi::Value &listenerId) {
+  unsubscribeFromKeyboardEventsFunction(listenerId.asNumber());
+}
+
 } // namespace reanimated

package/Common/cpp/NativeModules/NativeReanimatedModuleSpec.cpp

@@ -138,6 +138,25 @@ static jsi::Value SPEC_PREFIX(configureProps)(
   return jsi::Value::undefined();
 }
 
+static jsi::Value SPEC_PREFIX(subscribeForKeyboardEvents)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t count) {
+  return static_cast<NativeReanimatedModuleSpec *>(&turboModule)
+      ->subscribeForKeyboardEvents(rt, std::move(args[0]));
+}
+
+static jsi::Value SPEC_PREFIX(unsubscribeFromKeyboardEvents)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t count) {
+  static_cast<NativeReanimatedModuleSpec *>(&turboModule)
+      ->unsubscribeFromKeyboardEvents(rt, std::move(args[0]));
+  return jsi::Value::undefined();
+}
+
 NativeReanimatedModuleSpec::NativeReanimatedModuleSpec(
     std::shared_ptr<CallInvoker> jsInvoker)
     : TurboModule("NativeReanimated", jsInvoker) {
@@ -163,5 +182,9 @@ NativeReanimatedModuleSpec::NativeReanimatedModuleSpec(
   methodMap_["unregisterSensor"] =
       MethodMetadata{1, SPEC_PREFIX(unregisterSensor)};
   methodMap_["configureProps"] = MethodMetadata{2, SPEC_PREFIX(configureProps)};
+  methodMap_["subscribeForKeyboardEvents"] =
+      MethodMetadata{1, SPEC_PREFIX(subscribeForKeyboardEvents)};
+  methodMap_["unsubscribeFromKeyboardEvents"] =
+      MethodMetadata{1, SPEC_PREFIX(unsubscribeFromKeyboardEvents)};
 }
 } // namespace reanimated

package/Common/cpp/Registries/EventHandlerRegistry.cpp

@@ -25,7 +25,12 @@ void EventHandlerRegistry::unregisterEventHandler(unsigned long id) {
 void EventHandlerRegistry::processEvent(
     jsi::Runtime &rt,
     std::string eventName,
-    std::string eventPayload) {
+#ifdef RCT_NEW_ARCH_ENABLED
+    jsi::Value &eventPayload
+#else
+    std::string eventPayload
+#endif
+    /**/) {
   std::vector<std::shared_ptr<WorkletEventHandler>> handlersForEvent;
   {
     const std::lock_guard<std::mutex> lock(instanceMutex);
@@ -36,6 +41,13 @@ 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
@@ -57,6 +69,7 @@ void EventHandlerRegistry::processEvent(
   for (auto handler : handlersForEvent) {
     handler->process(rt, eventObject);
   }
+#endif
 }
 
 bool EventHandlerRegistry::isAnyHandlerWaitingForEvent(std::string eventName) {

package/Common/cpp/Registries/NewestShadowNodesRegistry.cpp

@@ -0,0 +1,68 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include "NewestShadowNodesRegistry.h"
+
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/core/ShadowNodeFragment.h>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+void NewestShadowNodesRegistry::set(
+    ShadowNode::Shared shadowNode,
+    Tag parentTag) {
+  map_[shadowNode->getTag()] = std::make_pair(shadowNode, parentTag);
+}
+
+bool NewestShadowNodesRegistry::has(
+    const ShadowNode::Shared &shadowNode) const {
+  return map_.find(shadowNode->getTag()) != map_.cend();
+}
+
+ShadowNode::Shared NewestShadowNodesRegistry::get(Tag tag) const {
+  const auto it = map_.find(tag);
+  return it != map_.cend() ? it->second.first : nullptr;
+}
+
+void NewestShadowNodesRegistry::update(ShadowNode::Shared shadowNode) {
+  const auto it = map_.find(shadowNode->getTag());
+  react_native_assert(it != map_.cend());
+  it->second.first = shadowNode;
+}
+
+void NewestShadowNodesRegistry::remove(Tag tag) {
+  if (map_.find(tag) == map_.cend()) {
+    return;
+  }
+
+  auto shadowNode = map_[tag].first;
+
+  while (shadowNode != nullptr) {
+    bool hasAnyChildInMap = false;
+    for (const auto &child : shadowNode->getChildren()) {
+      if (has(child)) {
+        hasAnyChildInMap = true;
+        break;
+      }
+    }
+
+    if (hasAnyChildInMap) {
+      break;
+    }
+
+    auto it = map_.find(shadowNode->getTag());
+    Tag parentTag = it->second.second;
+    map_.erase(it);
+
+    shadowNode = map_[parentTag].first;
+  }
+}
+
+std::lock_guard<std::mutex> NewestShadowNodesRegistry::createLock() const {
+  return std::lock_guard<std::mutex>(mutex_);
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/SharedItems/ShareableValue.cpp

@@ -1,4 +1,9 @@
 #include <cxxabi.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <react/renderer/uimanager/primitives.h>
+#endif
+
 #include "FrozenObject.h"
 #include "MutableValue.h"
 #include "MutableValueSetterProxy.h"
@@ -157,6 +162,13 @@ void ShareableValue::adapt(
       valueContainer =
           std::make_unique<RemoteObjectWrapper>(std::make_shared<RemoteObject>(
               rt, object, runtimeManager, runtimeManager->scheduler));
+#ifdef RCT_NEW_ARCH_ENABLED
+    } else if (object.isHostObject<ShadowNodeWrapper>(rt)) {
+      type = ValueType::ShadowNodeType;
+      auto shadowNode = object.getHostObject<ShadowNodeWrapper>(rt)->shadowNode;
+      valueContainer = std::make_unique<ShadowNodeValueWrapper>(shadowNode);
+      adaptCache(rt, value);
+#endif
     } else {
       // create frozen object based on a copy of a given object
       type = ValueType::FrozenObjectType;
@@ -278,6 +290,12 @@ jsi::Value ShareableValue::toJSValue(jsi::Runtime &rt) {
       auto &mutableObject = ValueWrapper::asMutableValue(valueContainer);
       return createHost(rt, mutableObject);
     }
+#ifdef RCT_NEW_ARCH_ENABLED
+    case ValueType::ShadowNodeType: {
+      auto &shadowNode = ValueWrapper::asShadowNode(valueContainer);
+      return createHost(rt, std::make_shared<ShadowNodeWrapper>(shadowNode));
+    }
+#endif
     case ValueType::HostFunctionType: {
       auto hostFunctionWrapper =
           ValueWrapper::asHostFunctionWrapper(valueContainer);

package/Common/cpp/Tools/Mapper.cpp

@@ -25,7 +25,11 @@ void Mapper::execute(jsi::Runtime &rt) {
   if (optimalizationLvl == 0) {
     mapper->callWithThis(rt, *mapper); // call styleUpdater
   } else {
+#ifdef RCT_NEW_ARCH_ENABLED
+    jsi::Value newStyle = userUpdater->call(rt).asObject(rt);
+#else
     jsi::Object newStyle = userUpdater->call(rt).asObject(rt);
+#endif
     auto jsViewDescriptorArray = viewDescriptors->getValue(rt)
                                      .getObject(rt)
                                      .getProperty(rt, "value")
@@ -34,11 +38,16 @@ void Mapper::execute(jsi::Runtime &rt) {
     for (int i = 0; i < jsViewDescriptorArray.length(rt); ++i) {
       auto jsViewDescriptor =
           jsViewDescriptorArray.getValueAtIndex(rt, i).getObject(rt);
-      (*updateProps)(
+#ifdef RCT_NEW_ARCH_ENABLED
+      updateProps(
+          rt, jsViewDescriptor.getProperty(rt, "shadowNodeWrapper"), newStyle);
+#else
+      updateProps(
           rt,
           static_cast<int>(jsViewDescriptor.getProperty(rt, "tag").asNumber()),
           jsViewDescriptor.getProperty(rt, "name"),
           newStyle);
+#endif
     }
   }
 }
@@ -52,10 +61,20 @@ void Mapper::enableFastMode(
   }
   viewDescriptors = jsViewDescriptors;
   this->optimalizationLvl = optimalizationLvl;
-  updateProps = &module->updaterFunction;
-  jsi::Runtime *rt = module->runtime.get();
+#ifdef RCT_NEW_ARCH_ENABLED
+  updateProps = [this](
+                    jsi::Runtime &rt,
+                    const jsi::Value &shadowNodeValue,
+                    const jsi::Value &props) {
+    this->module->updateProps(rt, shadowNodeValue, props);
+  };
+#else
+  // TODO: don't get public field, instead call this->module->updateProps
+  updateProps = module->updatePropsFunction;
+#endif
+  jsi::Runtime &rt = *module->runtime;
   userUpdater = std::make_shared<jsi::Function>(
-      updater->getValue(*rt).asObject(*rt).asFunction(*rt));
+      updater->getValue(rt).asObject(rt).asFunction(rt));
 }
 
 Mapper::~Mapper() {