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

package/Common/cpp/AnimatedSensor/AnimatedSensorModule.cpp

@@ -1,16 +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
@@ -22,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, "qw", newValues[0]);
-      value.setProperty(runtime, "qx", newValues[1]);
-      value.setProperty(runtime, "qy", newValues[2]);
-      value.setProperty(runtime, "qz", 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/{headers/AnimatedSensor → 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/Fabric/FabricUtils.cpp

@@ -1,7 +1,13 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 
+#if REACT_NATIVE_MINOR_VERSION < 69
+#error \
+    "Reanimated 3 does not support React Native 0.68.x when Fabric is enabled. Please upgrade to React Native 0.69.0 or newer if you want to use Reanimated with the new architecture."
+#endif
+
 #include "FabricUtils.h"
 
+#include <react/renderer/debug/SystraceSection.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
 
 using namespace facebook::react;
@@ -17,110 +23,10 @@ RuntimeExecutor getRuntimeExecutorFromBinding(Binding *binding) {
 }
 #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);
+  return reinterpret_cast<const UIManagerPublic *>(uiManager)
+      ->contextContainer_;
 }
 
 } // namespace reanimated

package/Common/cpp/{headers/Fabric → Fabric}/FabricUtils.h

@@ -2,21 +2,23 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 
 #ifdef ANDROID
-#include <Binding.h>
 #include <fbjni/fbjni.h>
+#include <react/fabric/Binding.h>
 #endif
 #include <react/renderer/uimanager/UIManager.h>
 
 #include <memory>
 #include <string>
 
-using namespace facebook::react;
+using namespace facebook;
+using namespace react;
 
 namespace reanimated {
 
 struct UIManagerBindingPublic {
   void *vtable;
   std::shared_ptr<UIManager> uiManager_;
+  std::unique_ptr<EventHandler const> eventHandler_;
 };
 
 struct UIManagerPublic {
@@ -51,28 +53,6 @@ RuntimeExecutor getRuntimeExecutorFromBinding(Binding *binding);
 std::shared_ptr<const ContextContainer> getContextContainerFromUIManager(
     const UIManager *uiManager);
 
-void UIManager_dispatchCommand(
-    const std::shared_ptr<UIManager> &uiManager,
-    const ShadowNode::Shared &shadowNode,
-    std::string const &commandName,
-    folly::dynamic const &args);
-
-LayoutMetrics UIManager_getRelativeLayoutMetrics(
-    const std::shared_ptr<UIManager> &uiManager,
-    ShadowNode const &shadowNode,
-    ShadowNode const *ancestorShadowNode,
-    LayoutableShadowNode::LayoutInspectingPolicy policy);
-
-SharedShadowNode UIManager_cloneNode(
-    const UIManager *uiManager,
-    const ShadowNode::Shared &shadowNode,
-    const SharedShadowNodeSharedList &children = nullptr,
-    const RawProps *rawProps = nullptr);
-
-void UIManager_appendChild(
-    const ShadowNode::Shared &parentShadowNode,
-    const ShadowNode::Shared &childShadowNode);
-
 } // namespace reanimated
 
 #endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/Fabric/ReanimatedUIManagerBinding.cpp

@@ -4,6 +4,10 @@
 #include "FabricUtils.h"
 #include "NewestShadowNodesRegistry.h"
 
+#include <react/renderer/debug/SystraceSection.h>
+
+#include <utility>
+
 using namespace facebook;
 using namespace react;
 
@@ -17,45 +21,87 @@ void ReanimatedUIManagerBinding::createAndInstallIfNeeded(
         &newestShadowNodesRegistry) {
   // adapted from UIManagerBinding.cpp
   auto uiManagerModuleName = "nativeFabricUIManager";
-  auto uiManagerBinding = std::make_shared<ReanimatedUIManagerBinding>(
-      uiManager, runtimeExecutor, newestShadowNodesRegistry);
-  auto object = jsi::Object::createFromHostObject(runtime, uiManagerBinding);
+
+  auto eventHandler = [&]() -> std::unique_ptr<EventHandler const> {
+    auto uiManagerValue =
+        runtime.global().getProperty(runtime, uiManagerModuleName);
+    if (uiManagerValue.isUndefined()) {
+      return nullptr;
+    }
+
+    auto uiManagerBinding =
+        uiManagerValue.asObject(runtime).asHostObject<UIManagerBinding>(
+            runtime);
+    auto uiManagerBindingPublic =
+        reinterpret_cast<UIManagerBindingPublic *>(&*uiManagerBinding);
+    return std::move(uiManagerBindingPublic->eventHandler_);
+  }();
+
+  auto reanimatedUiManagerBinding =
+      std::make_shared<ReanimatedUIManagerBinding>(
+          uiManager,
+          runtimeExecutor,
+          std::move(eventHandler),
+          newestShadowNodesRegistry);
+  auto object =
+      jsi::Object::createFromHostObject(runtime, reanimatedUiManagerBinding);
   runtime.global().setProperty(runtime, uiManagerModuleName, std::move(object));
 }
 
 ReanimatedUIManagerBinding::ReanimatedUIManagerBinding(
     std::shared_ptr<UIManager> uiManager,
     RuntimeExecutor runtimeExecutor,
+    std::unique_ptr<EventHandler const> eventHandler,
     std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry)
-    : UIManagerBinding(uiManager, runtimeExecutor),
+    : UIManagerBinding(uiManager),
       uiManager_(std::move(uiManager)),
-      newestShadowNodesRegistry_(newestShadowNodesRegistry) {}
+      newestShadowNodesRegistry_(newestShadowNodesRegistry) {
+  if (eventHandler != nullptr) {
+    reinterpret_cast<UIManagerBindingPublic *>(this)->eventHandler_ =
+        std::move(eventHandler);
+  }
+}
 
 ReanimatedUIManagerBinding::~ReanimatedUIManagerBinding() {}
 
-void ReanimatedUIManagerBinding::invalidate() const {
-  uiManager_->setDelegate(nullptr);
-}
-
-static inline ShadowNode::Shared cloneNode(
+static inline ShadowNode::Shared cloneNodeUsingNewest(
     UIManager *uiManager,
     NewestShadowNodesRegistry *newestShadowNodesRegistry,
-    const ShadowNode::Shared &shadowNode,
-    const SharedShadowNodeSharedList &children = nullptr,
-    const RawProps *rawProps = nullptr) {
+    ShadowNode const &shadowNode,
+    ShadowNode::SharedListOfShared const &children = nullptr,
+    RawProps const *rawProps = nullptr) {
   {
     auto lock = newestShadowNodesRegistry->createLock();
-    auto newest = newestShadowNodesRegistry->get(shadowNode->getTag());
+    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);
+      auto clone = uiManager->cloneNode(*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);
+  return uiManager->cloneNode(shadowNode, children, rawProps);
+}
+
+static inline void appendChildUsingNewest(
+    UIManager *uiManager,
+    NewestShadowNodesRegistry *newestShadowNodesRegistry,
+    const ShadowNode::Shared &parentShadowNode,
+    const ShadowNode::Shared &childShadowNode) {
+  {
+    auto lock = newestShadowNodesRegistry->createLock();
+    auto newestChildShadowNode =
+        newestShadowNodesRegistry->get(childShadowNode->getTag());
+    if (newestChildShadowNode != nullptr) {
+      uiManager->appendChild(parentShadowNode, newestChildShadowNode);
+      return;
+    }
+  } // release lock since we don't need registry anymore
+
+  // child ShadowNode not managed by Reanimated (yet?)
+  uiManager->appendChild(parentShadowNode, childShadowNode);
 }
 
 jsi::Value ReanimatedUIManagerBinding::get(
@@ -69,6 +115,7 @@ jsi::Value ReanimatedUIManagerBinding::get(
 
   // based on implementation from UIManagerBinding.cpp
   auto methodName = name.utf8(runtime);
+  SystraceSection s("ReanimatedUIManagerBinding::get", "name", methodName);
   UIManager *uiManager = uiManager_.get();
   NewestShadowNodesRegistry *newestShadowNodesRegistry =
       newestShadowNodesRegistry_.get();
@@ -81,15 +128,15 @@ jsi::Value ReanimatedUIManagerBinding::get(
         1,
         [uiManager, newestShadowNodesRegistry](
             jsi::Runtime &runtime,
-            jsi::Value const &thisValue,
+            jsi::Value const & /*thisValue*/,
             jsi::Value const *arguments,
-            size_t count) noexcept -> jsi::Value {
+            size_t /*count*/) noexcept -> jsi::Value {
           return valueFromShadowNode(
               runtime,
-              cloneNode(
+              cloneNodeUsingNewest(
                   uiManager,
                   newestShadowNodesRegistry,
-                  shadowNodeFromValue(runtime, arguments[0])));
+                  *shadowNodeFromValue(runtime, arguments[0])));
         });
   }
 
@@ -101,15 +148,15 @@ jsi::Value ReanimatedUIManagerBinding::get(
         1,
         [uiManager, newestShadowNodesRegistry](
             jsi::Runtime &runtime,
-            jsi::Value const &thisValue,
+            jsi::Value const & /*thisValue*/,
             jsi::Value const *arguments,
-            size_t count) noexcept -> jsi::Value {
+            size_t /*count*/) noexcept -> jsi::Value {
           return valueFromShadowNode(
               runtime,
-              cloneNode(
+              cloneNodeUsingNewest(
                   uiManager,
                   newestShadowNodesRegistry,
-                  shadowNodeFromValue(runtime, arguments[0]),
+                  *shadowNodeFromValue(runtime, arguments[0]),
                   ShadowNode::emptySharedShadowNodeSharedList()));
         });
   }
@@ -122,16 +169,16 @@ jsi::Value ReanimatedUIManagerBinding::get(
         2,
         [uiManager, newestShadowNodesRegistry](
             jsi::Runtime &runtime,
-            jsi::Value const &thisValue,
+            jsi::Value const & /*thisValue*/,
             jsi::Value const *arguments,
-            size_t count) noexcept -> jsi::Value {
+            size_t /*count*/) noexcept -> jsi::Value {
           auto const &rawProps = RawProps(runtime, arguments[1]);
           return valueFromShadowNode(
               runtime,
-              cloneNode(
+              cloneNodeUsingNewest(
                   uiManager,
                   newestShadowNodesRegistry,
-                  shadowNodeFromValue(runtime, arguments[0]),
+                  *shadowNodeFromValue(runtime, arguments[0]),
                   nullptr,
                   &rawProps));
         });
@@ -145,16 +192,16 @@ jsi::Value ReanimatedUIManagerBinding::get(
         2,
         [uiManager, newestShadowNodesRegistry](
             jsi::Runtime &runtime,
-            jsi::Value const &thisValue,
+            jsi::Value const & /*thisValue*/,
             jsi::Value const *arguments,
-            size_t count) noexcept -> jsi::Value {
+            size_t /*count*/) noexcept -> jsi::Value {
           auto const &rawProps = RawProps(runtime, arguments[1]);
           return valueFromShadowNode(
               runtime,
-              cloneNode(
+              cloneNodeUsingNewest(
                   uiManager,
                   newestShadowNodesRegistry,
-                  shadowNodeFromValue(runtime, arguments[0]),
+                  *shadowNodeFromValue(runtime, arguments[0]),
                   ShadowNode::emptySharedShadowNodeSharedList(),
                   &rawProps));
         });
@@ -165,21 +212,16 @@ jsi::Value ReanimatedUIManagerBinding::get(
         runtime,
         name,
         2,
-        [newestShadowNodesRegistry](
+        [uiManager, newestShadowNodesRegistry](
             jsi::Runtime &runtime,
-            jsi::Value const &thisValue,
+            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);
+            size_t /*count*/) noexcept -> jsi::Value {
+          appendChildUsingNewest(
+              uiManager,
+              newestShadowNodesRegistry,
+              shadowNodeFromValue(runtime, arguments[0]),
+              shadowNodeFromValue(runtime, arguments[1]));
           return jsi::Value::undefined();
         });
   }

package/Common/cpp/{headers/Fabric → Fabric}/ReanimatedUIManagerBinding.h

@@ -28,6 +28,7 @@ class ReanimatedUIManagerBinding : public UIManagerBinding {
   ReanimatedUIManagerBinding(
       std::shared_ptr<UIManager> uiManager,
       RuntimeExecutor runtimeExecutor,
+      std::unique_ptr<EventHandler const> eventHandler,
       std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry);
 
   ~ReanimatedUIManagerBinding();

package/Common/cpp/Fabric/ShadowTreeCloner.cpp

@@ -0,0 +1,92 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include "ShadowTreeCloner.h"
+#include "FabricUtils.h"
+
+namespace reanimated {
+
+ShadowTreeCloner::ShadowTreeCloner(
+    std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry,
+    std::shared_ptr<UIManager> uiManager,
+    SurfaceId surfaceId)
+    : newestShadowNodesRegistry_{newestShadowNodesRegistry},
+      propsParserContext_{
+          surfaceId,
+          *getContextContainerFromUIManager(&*uiManager)} {}
+
+ShadowTreeCloner::~ShadowTreeCloner() {
+#ifdef DEBUG
+  react_native_assert(
+      yogaChildrenUpdates_.empty() &&
+      "Deallocating `ShadowTreeCloner` without calling `updateYogaChildren`.");
+#endif
+}
+
+ShadowNode::Unshared ShadowTreeCloner::cloneWithNewProps(
+    const ShadowNode::Shared &oldRootNode,
+    const ShadowNodeFamily &family,
+    RawProps &&rawProps) {
+  // adapted from ShadowNode::cloneTree
+
+  auto ancestors = family.getAncestors(*oldRootNode);
+
+  if (ancestors.empty()) {
+    return ShadowNode::Unshared{nullptr};
+  }
+
+  auto &parent = ancestors.back();
+  auto &oldShadowNode = parent.first.get().getChildren().at(parent.second);
+
+  const auto newest = newestShadowNodesRegistry_->get(oldShadowNode->getTag());
+
+  const auto &source = newest == nullptr ? oldShadowNode : newest;
+
+  const auto props = source->getComponentDescriptor().cloneProps(
+      propsParserContext_, source->getProps(), rawProps);
+
+  auto newChildNode = source->clone({/* .props = */ props});
+
+  for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
+    auto &parentNode = it->first.get();
+    auto childIndex = it->second;
+
+    auto children = parentNode.getChildren();
+    const auto &oldChildNode = *children.at(childIndex);
+    react_native_assert(ShadowNode::sameFamily(oldChildNode, *newChildNode));
+
+    newestShadowNodesRegistry_->set(newChildNode, parentNode.getTag());
+
+    if (!parentNode.getSealed()) {
+      // Optimization: if a ShadowNode is unsealed, we can directly update its
+      // children instead of cloning the whole path to the root node.
+      auto &parentNodeNonConst = const_cast<ShadowNode &>(parentNode);
+      parentNodeNonConst.replaceChild(oldChildNode, newChildNode, childIndex);
+      yogaChildrenUpdates_.insert(&parentNodeNonConst);
+      return std::const_pointer_cast<ShadowNode>(oldRootNode);
+    }
+
+    children[childIndex] = newChildNode;
+
+    newChildNode = parentNode.clone({
+        ShadowNodeFragment::propsPlaceholder(),
+        std::make_shared<ShadowNode::ListOfShared>(children),
+    });
+  }
+
+  return std::const_pointer_cast<ShadowNode>(newChildNode);
+}
+
+void ShadowTreeCloner::updateYogaChildren() {
+  // Unfortunately, `replaceChild` does not update Yoga nodes, so we need to
+  // update them manually here.
+  for (ShadowNode *shadowNode : yogaChildrenUpdates_) {
+    static_cast<YogaLayoutableShadowNode *>(shadowNode)->updateYogaChildren();
+  }
+#ifdef DEBUG
+  yogaChildrenUpdates_.clear();
+#endif
+}
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/Fabric/ShadowTreeCloner.h

@@ -0,0 +1,41 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/uimanager/UIManager.h>
+
+#include <memory>
+#include <set>
+
+#include "NewestShadowNodesRegistry.h"
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+class ShadowTreeCloner {
+ public:
+  ShadowTreeCloner(
+      std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry,
+      std::shared_ptr<UIManager> uiManager,
+      SurfaceId surfaceId);
+
+  ~ShadowTreeCloner();
+
+  ShadowNode::Unshared cloneWithNewProps(
+      const ShadowNode::Shared &oldRootNode,
+      const ShadowNodeFamily &family,
+      RawProps &&rawProps);
+
+  void updateYogaChildren();
+
+ private:
+  std::shared_ptr<NewestShadowNodesRegistry> newestShadowNodesRegistry_;
+  PropsParserContext propsParserContext_;
+  std::set<ShadowNode *> yogaChildrenUpdates_;
+};
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED