@react-native-ohos/react-native-reanimated 4.0.1 → 4.0.2-beta.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedCommitHook.h

@@ -1,49 +1,49 @@
-#pragma once
-
-#include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
-#include <reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.h>
-
-#include <react/renderer/uimanager/UIManagerCommitHook.h>
-
-#include <memory>
-
-using namespace facebook::react;
-
-namespace reanimated {
-
-class ReanimatedCommitHook : public UIManagerCommitHook, public std::enable_shared_from_this<ReanimatedCommitHook> {
- public:
-  ReanimatedCommitHook(
-      const std::shared_ptr<UIManager> &uiManager,
-      const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
-      const std::shared_ptr<LayoutAnimationsProxyCommon> &layoutAnimationsProxy);
-
-  ~ReanimatedCommitHook() noexcept override;
-
-  void commitHookWasRegistered(UIManager const &) noexcept override {}
-
-  void commitHookWasUnregistered(UIManager const &) noexcept override {}
-
-  void maybeInitializeLayoutAnimations(SurfaceId surfaceId);
-
-  RootShadowNode::Unshared shadowTreeWillCommit(
-      ShadowTree const &shadowTree,
-      RootShadowNode::Shared const &oldRootShadowNode,
-      RootShadowNode::Unshared const &newRootShadowNode
-#if REACT_NATIVE_MINOR_VERSION >= 80
-      ,
-      const ShadowTreeCommitOptions &commitOptions
-#endif
-      ) noexcept override;
-
- private:
-  std::shared_ptr<UIManager> uiManager_;
-  std::shared_ptr<UpdatesRegistryManager> updatesRegistryManager_;
-  std::shared_ptr<LayoutAnimationsProxyCommon> layoutAnimationsProxy_;
-
-  SurfaceId currentMaxSurfaceId_ = -1;
-
-  std::mutex mutex_; // Protects `currentMaxSurfaceId_`.
-};
-
-} // namespace reanimated
+#pragma once
+
+#include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.h>
+
+#include <react/renderer/uimanager/UIManagerCommitHook.h>
+
+#include <memory>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+class ReanimatedCommitHook : public UIManagerCommitHook, public std::enable_shared_from_this<ReanimatedCommitHook> {
+ public:
+  ReanimatedCommitHook(
+      const std::shared_ptr<UIManager> &uiManager,
+      const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
+      const std::shared_ptr<LayoutAnimationsProxyCommon> &layoutAnimationsProxy);
+
+  ~ReanimatedCommitHook() noexcept override;
+
+  void commitHookWasRegistered(UIManager const &) noexcept override {}
+
+  void commitHookWasUnregistered(UIManager const &) noexcept override {}
+
+  void maybeInitializeLayoutAnimations(SurfaceId surfaceId);
+
+  RootShadowNode::Unshared shadowTreeWillCommit(
+      ShadowTree const &shadowTree,
+      RootShadowNode::Shared const &oldRootShadowNode,
+      RootShadowNode::Unshared const &newRootShadowNode
+#if REACT_NATIVE_MINOR_VERSION >= 80
+      ,
+      const ShadowTreeCommitOptions &commitOptions
+#endif
+      ) noexcept override;
+
+ private:
+  std::shared_ptr<UIManager> uiManager_;
+  std::shared_ptr<UpdatesRegistryManager> updatesRegistryManager_;
+  std::shared_ptr<LayoutAnimationsProxyCommon> layoutAnimationsProxy_;
+
+  SurfaceId currentMaxSurfaceId_ = -1;
+
+  std::mutex mutex_; // Protects `currentMaxSurfaceId_`.
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedCommitShadowNode.h

@@ -1,46 +1,46 @@
-#pragma once
-
-#include <react/renderer/core/ShadowNode.h>
-
-using namespace facebook::react;
-
-namespace reanimated {
-
-// We use this trait to mark that a commit was created by Reanimated.
-// Traits are copied when nodes are cloned, so this information
-// won't be lost unless someone explicitly overrides it.
-// We need this information to skip unnecessary updates in
-// the commit hook.
-// Currently RN traits go up to 10, so hopefully
-// the arbitrarily chosen numbers 27 and 28 will be safe :)
-
-// We have to use 2 traits, because we want to distinguish reanimated
-// commits both in the commit hook and mount hook. If we only had one trait
-// and didn't remove it in the commit hook, then any node that would clone
-// this node would also have our commit trait, rendering this trait useless.
-constexpr ShadowNodeTraits::Trait ReanimatedCommitTrait{1 << 27};
-constexpr ShadowNodeTraits::Trait ReanimatedMountTrait{1 << 28};
-
-class ReanimatedCommitShadowNode : public ShadowNode {
- public:
-  inline void setReanimatedCommitTrait() {
-    traits_.set(ReanimatedCommitTrait);
-  }
-  inline void unsetReanimatedCommitTrait() {
-    traits_.unset(ReanimatedCommitTrait);
-  }
-  inline bool hasReanimatedCommitTrait() {
-    return traits_.check(ReanimatedCommitTrait);
-  }
-  inline void setReanimatedMountTrait() {
-    traits_.set(ReanimatedMountTrait);
-  }
-  inline void unsetReanimatedMountTrait() {
-    traits_.unset(ReanimatedMountTrait);
-  }
-  inline bool hasReanimatedMountTrait() {
-    return traits_.check(ReanimatedMountTrait);
-  }
-};
-
-} // namespace reanimated
+#pragma once
+
+#include <react/renderer/core/ShadowNode.h>
+
+using namespace facebook::react;
+
+namespace reanimated {
+
+// We use this trait to mark that a commit was created by Reanimated.
+// Traits are copied when nodes are cloned, so this information
+// won't be lost unless someone explicitly overrides it.
+// We need this information to skip unnecessary updates in
+// the commit hook.
+// Currently RN traits go up to 10, so hopefully
+// the arbitrarily chosen numbers 27 and 28 will be safe :)
+
+// We have to use 2 traits, because we want to distinguish reanimated
+// commits both in the commit hook and mount hook. If we only had one trait
+// and didn't remove it in the commit hook, then any node that would clone
+// this node would also have our commit trait, rendering this trait useless.
+constexpr ShadowNodeTraits::Trait ReanimatedCommitTrait{1 << 27};
+constexpr ShadowNodeTraits::Trait ReanimatedMountTrait{1 << 28};
+
+class ReanimatedCommitShadowNode : public ShadowNode {
+ public:
+  inline void setReanimatedCommitTrait() {
+    traits_.set(ReanimatedCommitTrait);
+  }
+  inline void unsetReanimatedCommitTrait() {
+    traits_.unset(ReanimatedCommitTrait);
+  }
+  inline bool hasReanimatedCommitTrait() {
+    return traits_.check(ReanimatedCommitTrait);
+  }
+  inline void setReanimatedMountTrait() {
+    traits_.set(ReanimatedMountTrait);
+  }
+  inline void unsetReanimatedMountTrait() {
+    traits_.unset(ReanimatedMountTrait);
+  }
+  inline bool hasReanimatedMountTrait() {
+    return traits_.check(ReanimatedMountTrait);
+  }
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedMountHook.cpp

@@ -1,56 +1,56 @@
-#include <reanimated/Fabric/ReanimatedCommitShadowNode.h>
-#include <reanimated/Fabric/ReanimatedMountHook.h>
-#include <reanimated/Tools/ReanimatedSystraceSection.h>
-
-#include <memory>
-
-namespace reanimated {
-
-ReanimatedMountHook::ReanimatedMountHook(
-    const std::shared_ptr<UIManager> &uiManager,
-    const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
-    const std::function<void()> &requestFlush)
-    : uiManager_(uiManager), updatesRegistryManager_(updatesRegistryManager), requestFlush_(requestFlush) {
-  uiManager_->registerMountHook(*this);
-}
-
-ReanimatedMountHook::~ReanimatedMountHook() noexcept {
-  uiManager_->unregisterMountHook(*this);
-}
-
-void ReanimatedMountHook::shadowTreeDidMount(
-    const RootShadowNode::Shared &rootShadowNode,
-#if REACT_NATIVE_MINOR_VERSION >= 81
-    HighResTimeStamp
-#else
-    double
-#endif // REACT_NATIVE_MINOR_VERSION >= 81
-    ) noexcept {
-  ReanimatedSystraceSection s("ReanimatedMountHook::shadowTreeDidMount");
-
-  auto reaShadowNode = std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(
-      std::const_pointer_cast<RootShadowNode>(rootShadowNode));
-
-  if (reaShadowNode->hasReanimatedMountTrait()) {
-    // We mark reanimated commits with ReanimatedMountTrait. We don't want other
-    // shadow nodes to use this trait, but since this rootShadowNode is Shared,
-    // we don't have that guarantee. That's why we also unset this trait in the
-    // commit hook. We remove it here mainly for the sake of cleanliness.
-    reaShadowNode->unsetReanimatedMountTrait();
-    return;
-  }
-
-  {
-    auto lock = updatesRegistryManager_->lock();
-    updatesRegistryManager_->handleNodeRemovals(*rootShadowNode);
-
-    // When commit from React Native has finished, we reset the skip commit flag
-    // in order to allow Reanimated to commit its tree
-    updatesRegistryManager_->unpauseReanimatedCommits();
-    if (updatesRegistryManager_->shouldCommitAfterPause()) {
-      requestFlush_();
-    }
-  }
-}
-
-} // namespace reanimated
+#include <reanimated/Fabric/ReanimatedCommitShadowNode.h>
+#include <reanimated/Fabric/ReanimatedMountHook.h>
+#include <reanimated/Tools/ReanimatedSystraceSection.h>
+
+#include <memory>
+
+namespace reanimated {
+
+ReanimatedMountHook::ReanimatedMountHook(
+    const std::shared_ptr<UIManager> &uiManager,
+    const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
+    const std::function<void()> &requestFlush)
+    : uiManager_(uiManager), updatesRegistryManager_(updatesRegistryManager), requestFlush_(requestFlush) {
+  uiManager_->registerMountHook(*this);
+}
+
+ReanimatedMountHook::~ReanimatedMountHook() noexcept {
+  uiManager_->unregisterMountHook(*this);
+}
+
+void ReanimatedMountHook::shadowTreeDidMount(
+    const RootShadowNode::Shared &rootShadowNode,
+#if REACT_NATIVE_MINOR_VERSION >= 81
+    HighResTimeStamp
+#else
+    double
+#endif // REACT_NATIVE_MINOR_VERSION >= 81
+    ) noexcept {
+  ReanimatedSystraceSection s("ReanimatedMountHook::shadowTreeDidMount");
+
+  auto reaShadowNode = std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(
+      std::const_pointer_cast<RootShadowNode>(rootShadowNode));
+
+  if (reaShadowNode->hasReanimatedMountTrait()) {
+    // We mark reanimated commits with ReanimatedMountTrait. We don't want other
+    // shadow nodes to use this trait, but since this rootShadowNode is Shared,
+    // we don't have that guarantee. That's why we also unset this trait in the
+    // commit hook. We remove it here mainly for the sake of cleanliness.
+    reaShadowNode->unsetReanimatedMountTrait();
+    return;
+  }
+
+  {
+    auto lock = updatesRegistryManager_->lock();
+    updatesRegistryManager_->handleNodeRemovals(*rootShadowNode);
+
+    // When commit from React Native has finished, we reset the skip commit flag
+    // in order to allow Reanimated to commit its tree
+    updatesRegistryManager_->unpauseReanimatedCommits();
+    if (updatesRegistryManager_->shouldCommitAfterPause()) {
+      requestFlush_();
+    }
+  }
+}
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedMountHook.h

@@ -1,37 +1,37 @@
-#pragma once
-
-#include <reanimated/Fabric/ShadowTreeCloner.h>
-#include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
-
-#include <react/renderer/uimanager/UIManagerMountHook.h>
-
-#include <memory>
-
-namespace reanimated {
-
-using namespace facebook::react;
-
-class ReanimatedMountHook : public UIManagerMountHook {
- public:
-  ReanimatedMountHook(
-      const std::shared_ptr<UIManager> &uiManager,
-      const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
-      const std::function<void()> &requestFlush);
-  ~ReanimatedMountHook() noexcept override;
-
-  void shadowTreeDidMount(
-      RootShadowNode::Shared const &rootShadowNode,
-#if REACT_NATIVE_MINOR_VERSION >= 81
-      HighResTimeStamp mountTime
-#else
-      double mountTime
-#endif // REACT_NATIVE_MINOR_VERSION >= 81
-      ) noexcept override;
-
- private:
-  const std::shared_ptr<UIManager> uiManager_;
-  const std::shared_ptr<UpdatesRegistryManager> updatesRegistryManager_;
-  const std::function<void()> requestFlush_;
-};
-
-} // namespace reanimated
+#pragma once
+
+#include <reanimated/Fabric/ShadowTreeCloner.h>
+#include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
+
+#include <react/renderer/uimanager/UIManagerMountHook.h>
+
+#include <memory>
+
+namespace reanimated {
+
+using namespace facebook::react;
+
+class ReanimatedMountHook : public UIManagerMountHook {
+ public:
+  ReanimatedMountHook(
+      const std::shared_ptr<UIManager> &uiManager,
+      const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
+      const std::function<void()> &requestFlush);
+  ~ReanimatedMountHook() noexcept override;
+
+  void shadowTreeDidMount(
+      RootShadowNode::Shared const &rootShadowNode,
+#if REACT_NATIVE_MINOR_VERSION >= 81
+      HighResTimeStamp mountTime
+#else
+      double mountTime
+#endif // REACT_NATIVE_MINOR_VERSION >= 81
+      ) noexcept override;
+
+ private:
+  const std::shared_ptr<UIManager> uiManager_;
+  const std::shared_ptr<UpdatesRegistryManager> updatesRegistryManager_;
+  const std::function<void()> requestFlush_;
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ShadowTreeCloner.cpp

@@ -1,104 +1,104 @@
-#include <reanimated/Fabric/ShadowTreeCloner.h>
-#include <reanimated/Tools/ReanimatedSystraceSection.h>
-
-#include <memory>
-#include <ranges>
-#include <utility>
-
-namespace reanimated {
-
-Props::Shared mergeProps(const ShadowNode &shadowNode, const PropsMap &propsMap, const ShadowNodeFamily &family) {
-  ReanimatedSystraceSection s("ShadowTreeCloner::mergeProps");
-
-  const auto it = propsMap.find(&family);
-
-  if (it == propsMap.end()) {
-    return ShadowNodeFragment::propsPlaceholder();
-  }
-
-  PropsParserContext propsParserContext{shadowNode.getSurfaceId(), *shadowNode.getContextContainer()};
-  const auto &propsVector = it->second;
-  auto newProps = shadowNode.getProps();
-
-#ifdef ANDROID
-  if (propsVector.size() > 1) {
-    folly::dynamic newPropsDynamic = folly::dynamic::object;
-    for (const auto &props : propsVector) {
-      newPropsDynamic = folly::dynamic::merge(props.operator folly::dynamic(), newPropsDynamic);
-    }
-    return shadowNode.getComponentDescriptor().cloneProps(propsParserContext, newProps, RawProps(newPropsDynamic));
-  }
-#endif
-
-  for (const auto &props : propsVector) {
-    newProps = shadowNode.getComponentDescriptor().cloneProps(propsParserContext, newProps, RawProps(props));
-  }
-
-  return newProps;
-}
-
-std::shared_ptr<ShadowNode> cloneShadowTreeWithNewPropsRecursive(
-    const ShadowNode &shadowNode,
-    const ChildrenMap &childrenMap,
-    const PropsMap &propsMap) {
-  const auto family = &shadowNode.getFamily();
-  const auto affectedChildrenIt = childrenMap.find(family);
-  auto children = shadowNode.getChildren();
-
-  if (affectedChildrenIt != childrenMap.end()) {
-    for (const auto index : affectedChildrenIt->second) {
-      children[index] = cloneShadowTreeWithNewPropsRecursive(*children[index], childrenMap, propsMap);
-    }
-  }
-
-  return shadowNode.clone(
-      {mergeProps(shadowNode, propsMap, *family),
-       std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>(children),
-       shadowNode.getState(),
-       false});
-}
-
-RootShadowNode::Unshared cloneShadowTreeWithNewProps(const RootShadowNode &oldRootNode, const PropsMap &propsMap) {
-  ReanimatedSystraceSection s("ShadowTreeCloner::cloneShadowTreeWithNewProps");
-
-  ChildrenMap childrenMap;
-
-  {
-    ReanimatedSystraceSection s("ShadowTreeCloner::prepareChildrenMap");
-
-    for (auto &[family, _] : propsMap) {
-      const auto ancestors = family->getAncestors(oldRootNode);
-
-//      for (const auto &[parentNode, index] : std::ranges::reverse_view(ancestors)) {
-//        const auto parentFamily = &parentNode.get().getFamily();
-//        auto &affectedChildren = childrenMap[parentFamily];
-//
-//        if (affectedChildren.contains(index)) {
-//          continue;
-//        }
-//
-//        affectedChildren.insert(index);
-//      }
-       //TODO     
-       for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
-          const auto &[parentNode, index] = *it;
-          
-          const auto parentFamily = &parentNode.get().getFamily();
-          auto &affectedChildren = childrenMap[parentFamily];
-        
-          if (affectedChildren.find(index) != affectedChildren.end()) {
-            continue;
-          }
-        
-          affectedChildren.insert(index);
-       }          
-    }
-  }
-
-  // This cast is safe, because this function returns a clone
-  // of the oldRootNode, which is an instance of RootShadowNode
-  return std::static_pointer_cast<RootShadowNode>(
-      cloneShadowTreeWithNewPropsRecursive(oldRootNode, childrenMap, propsMap));
-}
-
-} // namespace reanimated
+#include <reanimated/Fabric/ShadowTreeCloner.h>
+#include <reanimated/Tools/ReanimatedSystraceSection.h>
+
+#include <memory>
+#include <ranges>
+#include <utility>
+
+namespace reanimated {
+
+Props::Shared mergeProps(const ShadowNode &shadowNode, const PropsMap &propsMap, const ShadowNodeFamily &family) {
+  ReanimatedSystraceSection s("ShadowTreeCloner::mergeProps");
+
+  const auto it = propsMap.find(&family);
+
+  if (it == propsMap.end()) {
+    return ShadowNodeFragment::propsPlaceholder();
+  }
+
+  PropsParserContext propsParserContext{shadowNode.getSurfaceId(), *shadowNode.getContextContainer()};
+  const auto &propsVector = it->second;
+  auto newProps = shadowNode.getProps();
+
+#ifdef ANDROID
+  if (propsVector.size() > 1) {
+    folly::dynamic newPropsDynamic = folly::dynamic::object;
+    for (const auto &props : propsVector) {
+      newPropsDynamic = folly::dynamic::merge(props.operator folly::dynamic(), newPropsDynamic);
+    }
+    return shadowNode.getComponentDescriptor().cloneProps(propsParserContext, newProps, RawProps(newPropsDynamic));
+  }
+#endif
+
+  for (const auto &props : propsVector) {
+    newProps = shadowNode.getComponentDescriptor().cloneProps(propsParserContext, newProps, RawProps(props));
+  }
+
+  return newProps;
+}
+
+std::shared_ptr<ShadowNode> cloneShadowTreeWithNewPropsRecursive(
+    const ShadowNode &shadowNode,
+    const ChildrenMap &childrenMap,
+    const PropsMap &propsMap) {
+  const auto family = &shadowNode.getFamily();
+  const auto affectedChildrenIt = childrenMap.find(family);
+  auto children = shadowNode.getChildren();
+
+  if (affectedChildrenIt != childrenMap.end()) {
+    for (const auto index : affectedChildrenIt->second) {
+      children[index] = cloneShadowTreeWithNewPropsRecursive(*children[index], childrenMap, propsMap);
+    }
+  }
+
+  return shadowNode.clone(
+      {mergeProps(shadowNode, propsMap, *family),
+       std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>(children),
+       shadowNode.getState(),
+       false});
+}
+
+RootShadowNode::Unshared cloneShadowTreeWithNewProps(const RootShadowNode &oldRootNode, const PropsMap &propsMap) {
+  ReanimatedSystraceSection s("ShadowTreeCloner::cloneShadowTreeWithNewProps");
+
+  ChildrenMap childrenMap;
+
+  {
+    ReanimatedSystraceSection s("ShadowTreeCloner::prepareChildrenMap");
+
+    for (auto &[family, _] : propsMap) {
+      const auto ancestors = family->getAncestors(oldRootNode);
+
+//      for (const auto &[parentNode, index] : std::ranges::reverse_view(ancestors)) {
+//        const auto parentFamily = &parentNode.get().getFamily();
+//        auto &affectedChildren = childrenMap[parentFamily];
+//
+//        if (affectedChildren.contains(index)) {
+//          continue;
+//        }
+//
+//        affectedChildren.insert(index);
+//      }
+       //TODO     
+       for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
+          const auto &[parentNode, index] = *it;
+          
+          const auto parentFamily = &parentNode.get().getFamily();
+          auto &affectedChildren = childrenMap[parentFamily];
+        
+          if (affectedChildren.find(index) != affectedChildren.end()) {
+            continue;
+          }
+        
+          affectedChildren.insert(index);
+       }          
+    }
+  }
+
+  // This cast is safe, because this function returns a clone
+  // of the oldRootNode, which is an instance of RootShadowNode
+  return std::static_pointer_cast<RootShadowNode>(
+      cloneShadowTreeWithNewPropsRecursive(oldRootNode, childrenMap, propsMap));
+}
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ShadowTreeCloner.h

@@ -1,22 +1,22 @@
-#pragma once
-
-#include <react/renderer/core/PropsParserContext.h>
-#include <react/renderer/uimanager/UIManager.h>
-
-#include <memory>
-#include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-using namespace facebook;
-using namespace react;
-
-namespace reanimated {
-
-using PropsMap = std::unordered_map<const ShadowNodeFamily *, std::vector<RawProps>>;
-using ChildrenMap = std::unordered_map<const ShadowNodeFamily *, std::unordered_set<int>>;
-
-RootShadowNode::Unshared cloneShadowTreeWithNewProps(const RootShadowNode &oldRootNode, const PropsMap &propsMap);
-
-} // namespace reanimated
+#pragma once
+
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/uimanager/UIManager.h>
+
+#include <memory>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+using namespace facebook;
+using namespace react;
+
+namespace reanimated {
+
+using PropsMap = std::unordered_map<const ShadowNodeFamily *, std::vector<RawProps>>;
+using ChildrenMap = std::unordered_map<const ShadowNodeFamily *, std::unordered_set<int>>;
+
+RootShadowNode::Unshared cloneShadowTreeWithNewProps(const RootShadowNode &oldRootNode, const PropsMap &propsMap);
+
+} // namespace reanimated