react-native-reanimated 2.8.0 → 3.0.0-rc.0

package/Common/cpp/Fabric/FabricUtils.cpp

@@ -0,0 +1,128 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include "FabricUtils.h"
+
+#include <react/renderer/uimanager/UIManagerBinding.h>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+#ifdef ANDROID
+RuntimeExecutor getRuntimeExecutorFromBinding(Binding *binding) {
+  BindingPublic *bindingPublic = reinterpret_cast<BindingPublic *>(binding);
+  SchedulerPublic *schedulerPublic =
+      reinterpret_cast<SchedulerPublic *>((bindingPublic->scheduler_).get());
+  return schedulerPublic->runtimeExecutor_;
+}
+#endif
+
+inline static const UIManagerPublic *getUIManagerPublic(
+    const UIManager *uiManager) {
+  return reinterpret_cast<const UIManagerPublic *>(uiManager);
+}
+
+std::shared_ptr<const ContextContainer> getContextContainerFromUIManager(
+    const UIManager *uiManager) {
+  return getUIManagerPublic(uiManager)->contextContainer_;
+}
+
+inline static UIManagerDelegate *getDelegateFromUIManager(
+    const UIManager *uiManager) {
+  return getUIManagerPublic(uiManager)->delegate_;
+}
+
+void UIManager_dispatchCommand(
+    const std::shared_ptr<UIManager> &uiManager,
+    const ShadowNode::Shared &shadowNode,
+    std::string const &commandName,
+    folly::dynamic const &args) {
+  auto delegate_ = getDelegateFromUIManager(&*uiManager);
+
+  // copied from UIManager.cpp
+  if (delegate_) {
+    delegate_->uiManagerDidDispatchCommand(shadowNode, commandName, args);
+  }
+}
+
+LayoutMetrics UIManager_getRelativeLayoutMetrics(
+    const std::shared_ptr<UIManager> &uiManager,
+    ShadowNode const &shadowNode,
+    ShadowNode const *ancestorShadowNode,
+    LayoutableShadowNode::LayoutInspectingPolicy policy) {
+  // based on implementation from UIManager.cpp
+  const auto &shadowTreeRegistry = uiManager->getShadowTreeRegistry();
+
+  // We might store here an owning pointer to `ancestorShadowNode` to ensure
+  // that the node is not deallocated during method execution lifetime.
+  auto owningAncestorShadowNode = ShadowNode::Shared{};
+
+  if (!ancestorShadowNode) {
+    shadowTreeRegistry.visit(
+        shadowNode.getSurfaceId(), [&](ShadowTree const &shadowTree) {
+          owningAncestorShadowNode =
+              shadowTree.getCurrentRevision().rootShadowNode;
+          ancestorShadowNode = owningAncestorShadowNode.get();
+        });
+  } else {
+    // It is possible for JavaScript (or other callers) to have a reference
+    // to a previous version of ShadowNodes, but we enforce that
+    // metrics are only calculated on most recently committed versions.
+    owningAncestorShadowNode =
+        uiManager->getNewestCloneOfShadowNode(*ancestorShadowNode);
+    ancestorShadowNode = owningAncestorShadowNode.get();
+  }
+
+  auto layoutableAncestorShadowNode =
+      traitCast<LayoutableShadowNode const *>(ancestorShadowNode);
+
+  if (!layoutableAncestorShadowNode) {
+    return EmptyLayoutMetrics;
+  }
+
+  return LayoutableShadowNode::computeRelativeLayoutMetrics(
+      shadowNode.getFamily(), *layoutableAncestorShadowNode, policy);
+}
+
+SharedShadowNode UIManager_cloneNode(
+    const UIManager *uiManager,
+    const ShadowNode::Shared &shadowNode,
+    const SharedShadowNodeSharedList &children,
+    const RawProps *rawProps) {
+  auto delegate_ = getDelegateFromUIManager(uiManager);
+  auto contextContainer_ = getContextContainerFromUIManager(uiManager);
+
+  // copied from UIManager.cpp
+  PropsParserContext propsParserContext{
+      shadowNode->getFamily().getSurfaceId(), *contextContainer_.get()};
+
+  auto &componentDescriptor = shadowNode->getComponentDescriptor();
+  auto clonedShadowNode = componentDescriptor.cloneShadowNode(
+      *shadowNode,
+      {
+          /* .props = */
+          rawProps ? componentDescriptor.cloneProps(
+                         propsParserContext, shadowNode->getProps(), *rawProps)
+                   : ShadowNodeFragment::propsPlaceholder(),
+          /* .children = */ children,
+      });
+
+  if (delegate_) {
+    delegate_->uiManagerDidCloneShadowNode(
+        *shadowNode.get(), *clonedShadowNode);
+  }
+
+  return clonedShadowNode;
+}
+
+void UIManager_appendChild(
+    const ShadowNode::Shared &parentShadowNode,
+    const ShadowNode::Shared &childShadowNode) {
+  // copied from UIManager.cpp
+  auto &componentDescriptor = parentShadowNode->getComponentDescriptor();
+  componentDescriptor.appendChild(parentShadowNode, childShadowNode);
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/Fabric/ReanimatedUIManagerBinding.cpp

@@ -0,0 +1,197 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include "ReanimatedUIManagerBinding.h"
+#include "FabricUtils.h"
+#include "NewestShadowNodesRegistry.h"
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+void ReanimatedUIManagerBinding::createAndInstallIfNeeded(
+    jsi::Runtime &runtime,
+    RuntimeExecutor const &runtimeExecutor,
+    std::shared_ptr<UIManager> const &uiManager,
+    std::shared_ptr<NewestShadowNodesRegistry> const
+        &newestShadowNodesRegistry) {
+  // adapted from UIManagerBinding.cpp
+  auto uiManagerModuleName = "nativeFabricUIManager";
+  auto uiManagerBinding = std::make_shared<ReanimatedUIManagerBinding>(
+      uiManager, runtimeExecutor, newestShadowNodesRegistry);
+  auto object = jsi::Object::createFromHostObject(runtime, uiManagerBinding);
+  runtime.global().setProperty(runtime, uiManagerModuleName, std::move(object));
+}
+
+ReanimatedUIManagerBinding::ReanimatedUIManagerBinding(
+    std::shared_ptr<UIManager> uiManager,
+    RuntimeExecutor runtimeExecutor,
+    std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry)
+    : UIManagerBinding(uiManager, runtimeExecutor),
+      uiManager_(std::move(uiManager)),
+      newestShadowNodesRegistry_(newestShadowNodesRegistry) {}
+
+ReanimatedUIManagerBinding::~ReanimatedUIManagerBinding() {}
+
+void ReanimatedUIManagerBinding::invalidate() const {
+  uiManager_->setDelegate(nullptr);
+}
+
+static inline ShadowNode::Shared cloneNode(
+    UIManager *uiManager,
+    NewestShadowNodesRegistry *newestShadowNodesRegistry,
+    const ShadowNode::Shared &shadowNode,
+    const SharedShadowNodeSharedList &children = nullptr,
+    const RawProps *rawProps = nullptr) {
+  {
+    auto lock = newestShadowNodesRegistry->createLock();
+    auto newest = newestShadowNodesRegistry->get(shadowNode->getTag());
+    if (newest != nullptr) {
+      // ShadowNode managed by Reanimated, use newest ShadowNode from registry
+      auto clone = UIManager_cloneNode(uiManager, newest, children, rawProps);
+      newestShadowNodesRegistry->update(clone);
+      return clone;
+    }
+  } // release lock since we don't need registry anymore
+
+  // ShadowNode not managed by Reanimated (yet?)
+  return UIManager_cloneNode(uiManager, shadowNode, children, rawProps);
+}
+
+jsi::Value ReanimatedUIManagerBinding::get(
+    jsi::Runtime &runtime,
+    jsi::PropNameID const &name) {
+  // Currently, we need to overwrite all variants of `cloneNode` as well as
+  // `appendChild` to prevent React from overwriting layout props animated using
+  // Reanimated. However, this may degrade performance due to using locks.
+  // We already have an idea how this can be done better without locks
+  // (i.e. by overwriting `completeRoot` and using UIManagerCommitHooks).
+
+  // based on implementation from UIManagerBinding.cpp
+  auto methodName = name.utf8(runtime);
+  UIManager *uiManager = uiManager_.get();
+  NewestShadowNodesRegistry *newestShadowNodesRegistry =
+      newestShadowNodesRegistry_.get();
+
+  // Semantic: Clones the node with *same* props and *same* children.
+  if (methodName == "cloneNode") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        1,
+        [uiManager, newestShadowNodesRegistry](
+            jsi::Runtime &runtime,
+            jsi::Value const &thisValue,
+            jsi::Value const *arguments,
+            size_t count) noexcept -> jsi::Value {
+          return valueFromShadowNode(
+              runtime,
+              cloneNode(
+                  uiManager,
+                  newestShadowNodesRegistry,
+                  shadowNodeFromValue(runtime, arguments[0])));
+        });
+  }
+
+  // Semantic: Clones the node with *same* props and *empty* children.
+  if (methodName == "cloneNodeWithNewChildren") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        1,
+        [uiManager, newestShadowNodesRegistry](
+            jsi::Runtime &runtime,
+            jsi::Value const &thisValue,
+            jsi::Value const *arguments,
+            size_t count) noexcept -> jsi::Value {
+          return valueFromShadowNode(
+              runtime,
+              cloneNode(
+                  uiManager,
+                  newestShadowNodesRegistry,
+                  shadowNodeFromValue(runtime, arguments[0]),
+                  ShadowNode::emptySharedShadowNodeSharedList()));
+        });
+  }
+
+  // Semantic: Clones the node with *given* props and *same* children.
+  if (methodName == "cloneNodeWithNewProps") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        2,
+        [uiManager, newestShadowNodesRegistry](
+            jsi::Runtime &runtime,
+            jsi::Value const &thisValue,
+            jsi::Value const *arguments,
+            size_t count) noexcept -> jsi::Value {
+          auto const &rawProps = RawProps(runtime, arguments[1]);
+          return valueFromShadowNode(
+              runtime,
+              cloneNode(
+                  uiManager,
+                  newestShadowNodesRegistry,
+                  shadowNodeFromValue(runtime, arguments[0]),
+                  nullptr,
+                  &rawProps));
+        });
+  }
+
+  // Semantic: Clones the node with *given* props and *empty* children.
+  if (methodName == "cloneNodeWithNewChildrenAndProps") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        2,
+        [uiManager, newestShadowNodesRegistry](
+            jsi::Runtime &runtime,
+            jsi::Value const &thisValue,
+            jsi::Value const *arguments,
+            size_t count) noexcept -> jsi::Value {
+          auto const &rawProps = RawProps(runtime, arguments[1]);
+          return valueFromShadowNode(
+              runtime,
+              cloneNode(
+                  uiManager,
+                  newestShadowNodesRegistry,
+                  shadowNodeFromValue(runtime, arguments[0]),
+                  ShadowNode::emptySharedShadowNodeSharedList(),
+                  &rawProps));
+        });
+  }
+
+  if (methodName == "appendChild") {
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        name,
+        2,
+        [newestShadowNodesRegistry](
+            jsi::Runtime &runtime,
+            jsi::Value const &thisValue,
+            jsi::Value const *arguments,
+            size_t count) noexcept -> jsi::Value {
+          auto parent = shadowNodeFromValue(runtime, arguments[0]);
+          auto child = shadowNodeFromValue(runtime, arguments[1]);
+          {
+            auto lock = newestShadowNodesRegistry->createLock();
+            auto newest = newestShadowNodesRegistry->get(child->getTag());
+            if (newest != nullptr) {
+              child = newest;
+            }
+          }
+          UIManager_appendChild(parent, child);
+          return jsi::Value::undefined();
+        });
+  }
+
+  // Methods like "findNodeAtPoint", "getRelativeLayoutMetrics", "measure" etc.
+  // use `UIManager::getNewestCloneOfShadowNode` or
+  // `ShadowTree::getCurrentRevision` under the hood,
+  // so there's no need to overwrite them.
+
+  return UIManagerBinding::get(runtime, name);
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/NativeModules/NativeReanimatedModule.cpp

@@ -1,7 +1,20 @@
 #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"
+#endif
+
 #include "EventHandlerRegistry.h"
 #include "FeaturesConfig.h"
 #include "FrozenObject.h"
@@ -62,8 +75,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 +88,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 +109,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 +157,12 @@ NativeReanimatedModule::NativeReanimatedModule(
     this->renderRequested = false;
     this->onRender(timestampMs);
   };
-  updaterFunction = platformDepMethodsHolder.updaterFunction;
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  // nothing
+#else
+  updatePropsFunction = platformDepMethodsHolder.updatePropsFunction;
+#endif
 }
 
 void NativeReanimatedModule::installCoreFunctions(
@@ -253,15 +318,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 +410,226 @@ 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();
+  auto contextContainer = getContextContainerFromUIManager(
+      &*uiManager_); // TODO: use Scheduler::getContextContainer
+  PropsParserContext propsParserContext{surfaceId_, *contextContainer};
+  jsi::Runtime &rt = *runtime.get();
+
+  shadowTreeRegistry.visit(surfaceId_, [&](ShadowTree const &shadowTree) {
+    shadowTree.commit([&](RootShadowNode const &oldRootShadowNode) {
+      // lock once due to performance reasons
+      auto lock = newestShadowNodesRegistry_->createLock();
+
+      auto rootNode = oldRootShadowNode.ShadowNode::clone(ShadowNodeFragment{});
+
+      for (const auto &pair : copiedOperationsQueue) {
+        const ShadowNodeFamily &family = pair.first->getFamily();
+        react_native_assert(family.getSurfaceId() == surfaceId_);
+
+        auto newRootNode =
+            rootNode->cloneTree(family, [&](ShadowNode const &oldShadowNode) {
+              const auto newest =
+                  newestShadowNodesRegistry_->get(oldShadowNode.getTag());
+
+              const auto &source = newest == nullptr ? oldShadowNode : *newest;
+
+              const auto newProps = source.getComponentDescriptor().cloneProps(
+                  propsParserContext,
+                  source.getProps(),
+                  RawProps(rt, *pair.second));
+
+              return source.clone({/* .props = */ newProps});
+            });
+
+        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;
+
+        auto ancestors = family.getAncestors(*rootNode);
+        for (const auto &pair : ancestors) {
+          const auto &parent = pair.first.get();
+          const auto &child = parent.getChildren().at(pair.second);
+          newestShadowNodesRegistry_->set(child, parent.getTag());
+        }
+      }
+
+      // remove ShadowNodes and its ancestors from NewestShadowNodesRegistry
+      for (auto tag : copiedTagsToRemove) {
+        newestShadowNodesRegistry_->remove(tag);
+      }
+
+      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
+
 } // namespace reanimated