@react-native-ohos/react-native-reanimated 3.18.2-rc.2 → 4.0.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Legacy.h

@@ -0,0 +1,220 @@
+#pragma once
+
+#include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
+#include <react/renderer/mounting/MountingOverrideDelegate.h>
+#include <react/renderer/scheduler/Scheduler.h>
+#include <react/renderer/uimanager/UIManagerAnimationDelegate.h>
+#include <react/renderer/uimanager/UIManagerBinding.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsUtils.h>
+#include <reanimated/Tools/PlatformDepMethodsHolder.h>
+#include <worklets/Tools/UIScheduler.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace reanimated {
+
+class ReanimatedModuleProxy;
+
+using namespace facebook;
+
+typedef enum ExitingState_Legacy {
+  UNDEFINED = 1,
+  WAITING = 2,
+  ANIMATING = 4,
+  DEAD = 8,
+  MOVED = 16,
+  DELETED = 32,
+} ExitingState_Legacy;
+
+struct MutationNode;
+
+/**
+ Represents a view that was either removed or had a child removed from the
+ ShadowTree
+ */
+struct Node {
+  std::vector<std::shared_ptr<MutationNode>> children, unflattenedChildren;
+  std::shared_ptr<Node> parent, unflattenedParent;
+  Tag tag;
+  void removeChildFromUnflattenedTree(std::shared_ptr<MutationNode> child);
+  void applyMutationToIndices(ShadowViewMutation mutation);
+  void insertChildren(std::vector<std::shared_ptr<MutationNode>> &newChildren);
+  void insertUnflattenedChildren(std::vector<std::shared_ptr<MutationNode>> &newChildren);
+  virtual bool isMutationNode();
+  explicit Node(const Tag tag) : tag(tag) {}
+  Node(Node &&node)
+      : children(std::move(node.children)), unflattenedChildren(std::move(node.unflattenedChildren)), tag(node.tag) {}
+  Node(Node &node) : children(node.children), unflattenedChildren(node.unflattenedChildren), tag(node.tag) {}
+  virtual ~Node() = default;
+};
+
+/**
+ Represents a view that was removed from the ShadowTree
+ */
+struct MutationNode : public Node {
+  ShadowViewMutation mutation;
+  ExitingState_Legacy state = UNDEFINED;
+  explicit MutationNode(ShadowViewMutation &mutation) : Node(mutation.oldChildShadowView.tag), mutation(mutation) {}
+  MutationNode(ShadowViewMutation &mutation, Node &&node) : Node(std::move(node)), mutation(mutation) {}
+  bool isMutationNode() override;
+};
+
+static inline bool isRNSScreen(std::shared_ptr<MutationNode> node) {
+  const auto &componentName = node->mutation.oldChildShadowView.componentName;
+  return !std::strcmp(componentName, "RNSScreenStack") || !std::strcmp(componentName, "RNSScreen") ||
+      !std::strcmp(componentName, "RNSModalScreen");
+}
+
+static inline void mergeAndSwap(
+    std::vector<std::shared_ptr<MutationNode>> &A,
+    std::vector<std::shared_ptr<MutationNode>> &B) {
+  std::vector<std::shared_ptr<MutationNode>> merged;
+  auto it1 = A.begin(), it2 = B.begin();
+  while (it1 != A.end() && it2 != B.end()) {
+    if ((*it1)->mutation.index < (*it2)->mutation.index) {
+      merged.push_back(*it1);
+      it1++;
+    } else {
+      merged.push_back(*it2);
+      it2++;
+    }
+  }
+  while (it1 != A.end()) {
+    merged.push_back(*it1);
+    it1++;
+  }
+  while (it2 != B.end()) {
+    merged.push_back(*it2);
+    it2++;
+  }
+  std::swap(A, merged);
+}
+
+struct SurfaceContext {
+  mutable std::unordered_set<std::shared_ptr<MutationNode>> deadNodes;
+};
+
+struct LayoutAnimationsProxy_Legacy : public LayoutAnimationsProxyCommon,
+                                      public UIManagerAnimationDelegate,
+                                      public std::enable_shared_from_this<LayoutAnimationsProxy_Legacy> {
+  mutable std::unordered_map<Tag, std::shared_ptr<Node>> nodeForTag_;
+  mutable std::recursive_mutex mutex;
+  mutable SurfaceManager surfaceManager;
+  mutable std::unordered_map<SurfaceId, SurfaceContext> surfaceContext_;
+  mutable std::unordered_map<Tag, int> leastRemoved;
+  mutable std::unordered_set<SurfaceId> surfacesToRemove_;
+
+  LayoutAnimationsProxy_Legacy(
+      std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager,
+      SharedComponentDescriptorRegistry componentDescriptorRegistry,
+      std::shared_ptr<const ContextContainer> contextContainer,
+      jsi::Runtime &uiRuntime,
+      const std::shared_ptr<UIScheduler> &uiScheduler
+#ifdef ANDROID
+      ,
+      PreserveMountedTagsFunction filterUnmountedTagsFunction,
+      std::shared_ptr<UIManager> uiManager,
+      std::shared_ptr<CallInvoker> jsInvoker
+#endif
+      )
+      : LayoutAnimationsProxyCommon(
+            std::move(layoutAnimationsManager),
+            std::move(componentDescriptorRegistry),
+            std::move(contextContainer),
+            uiRuntime,
+            uiScheduler
+#ifdef ANDROID
+            ,
+            std::move(filterUnmountedTagsFunction),
+            std::move(uiManager),
+            std::move(jsInvoker)
+#endif
+        ) {
+  }
+
+  void startEnteringAnimation(const int tag, ShadowViewMutation &mutation) const;
+  void startExitingAnimation(const int tag, ShadowViewMutation &mutation) const;
+  void startLayoutAnimation(const int tag, const ShadowViewMutation &mutation) const;
+
+  void transferConfigFromNativeID(const std::string &nativeId, const int tag) const;
+  std::optional<SurfaceId> progressLayoutAnimation(int tag, const jsi::Object &newStyle) override;
+  std::optional<SurfaceId> endLayoutAnimation(int tag, bool shouldRemove) override;
+  void maybeCancelAnimation(const int tag) const;
+
+  void parseRemoveMutations(
+      std::unordered_map<Tag, Tag> &movedViews,
+      ShadowViewMutationList &mutations,
+      std::vector<std::shared_ptr<MutationNode>> &roots) const;
+  void handleRemovals(
+      ShadowViewMutationList &filteredMutations,
+      std::vector<std::shared_ptr<MutationNode>> &roots,
+      std::unordered_set<std::shared_ptr<MutationNode>> &deadNodes,
+      bool shouldAnimate) const;
+
+  void handleUpdatesAndEnterings(
+      ShadowViewMutationList &filteredMutations,
+      const std::unordered_map<Tag, Tag> &movedViews,
+      ShadowViewMutationList &mutations,
+      const PropsParserContext &propsParserContext,
+      SurfaceId surfaceId) const;
+  void addOngoingAnimations(SurfaceId surfaceId, ShadowViewMutationList &mutations) const;
+  void updateOngoingAnimationTarget(const int tag, const ShadowViewMutation &mutation) const;
+  std::shared_ptr<ShadowView> cloneViewWithoutOpacity(
+      facebook::react::ShadowViewMutation &mutation,
+      const PropsParserContext &propsParserContext) const;
+  void maybeRestoreOpacity(LayoutAnimation &layoutAnimation, const jsi::Object &newStyle) const;
+  void maybeUpdateWindowDimensions(facebook::react::ShadowViewMutation &mutation, SurfaceId surfaceId) const;
+  void createLayoutAnimation(
+      const ShadowViewMutation &mutation,
+      ShadowView &oldView,
+      const SurfaceId &surfaceId,
+      const int tag) const;
+
+  void updateIndexForMutation(ShadowViewMutation &mutation) const;
+
+  void removeRecursively(std::shared_ptr<MutationNode> node, ShadowViewMutationList &mutations) const;
+  bool startAnimationsRecursively(
+      const std::shared_ptr<MutationNode> &node,
+      bool shouldRemoveSubviewsWithoutAnimations,
+      bool shouldAnimate,
+      bool isScreenPop,
+      ShadowViewMutationList &mutations) const;
+  void endAnimationsRecursively(const std::shared_ptr<MutationNode> &node, ShadowViewMutationList &mutations) const;
+  void maybeDropAncestors(
+      const std::shared_ptr<Node> &node,
+      const std::shared_ptr<MutationNode> &child,
+      ShadowViewMutationList &cleanupMutations) const;
+
+  const ComponentDescriptor &getComponentDescriptorForShadowView(const ShadowView &shadowView) const;
+  // MountingOverrideDelegate
+
+  bool shouldOverridePullTransaction() const override;
+  std::optional<MountingTransaction> pullTransaction(
+      SurfaceId surfaceId,
+      MountingTransaction::Number number,
+      const TransactionTelemetry &telemetry,
+      ShadowViewMutationList mutations) const override;
+
+  // UIManagerAnimationDelegate
+
+  void uiManagerDidConfigureNextLayoutAnimation(
+      jsi::Runtime &runtime,
+      const RawValue &config,
+      const jsi::Value &successCallbackValue,
+      const jsi::Value &failureCallbackValue) const override;
+
+  void setComponentDescriptorRegistry(const SharedComponentDescriptorRegistry &componentDescriptorRegistry) override;
+
+  bool shouldAnimateFrame() const override;
+
+  void stopSurface(SurfaceId surfaceId) override;
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsUtils.cpp

@@ -1,91 +1,31 @@
-#ifdef RCT_NEW_ARCH_ENABLED
-#include <reanimated/LayoutAnimations/LayoutAnimationsUtils.h>
-
-namespace reanimated {
-
-std::unordered_map<Tag, UpdateValues> &SurfaceManager::getUpdateMap(
-    SurfaceId surfaceId) {
-  auto props = props_.find(surfaceId);
-  if (props != props_.end()) {
-    return *props->second;
-  }
-
-  auto newProps = std::make_shared<std::unordered_map<Tag, UpdateValues>>();
-  props_.insert_or_assign(surfaceId, newProps);
-  return *newProps;
-}
-
-void SurfaceManager::updateWindow(
-    const SurfaceId surfaceId,
-    const double windowWidth,
-    const double windowHeight) {
-  windows_.insert_or_assign(surfaceId, Rect{windowWidth, windowHeight});
-}
-
-Rect SurfaceManager::getWindow(SurfaceId surfaceId) {
-  auto windowIt = windows_.find(surfaceId);
-  if (windowIt != windows_.end()) {
-    return windowIt->second;
-  }
-  return Rect{0, 0};
-}
-
-void Node::applyMutationToIndices(ShadowViewMutation mutation) {
-#if REACT_NATIVE_MINOR_VERSION >= 78
-  const auto parentTag = mutation.parentTag;
-#else
-  const auto parentTag = mutation.parentShadowView.tag;
-#endif // REACT_NATIVE_MINOR_VERSION >= 78
-
-  if (tag != parentTag) {
-    return;
-  }
-
-  int delta = mutation.type == ShadowViewMutation::Insert ? 1 : -1;
-  for (int i = children.size() - 1; i >= 0; i--) {
-    if (children[i]->mutation.index < mutation.index) {
-      return;
-    }
-    children[i]->mutation.index += delta;
-  }
-}
-
-// Should only be called on unflattened parents
-void Node::removeChildFromUnflattenedTree(std::shared_ptr<MutationNode> child) {
-  for (int i = unflattenedChildren.size() - 1; i >= 0; i--) {
-    if (unflattenedChildren[i]->tag == child->tag) {
-      unflattenedChildren.erase(unflattenedChildren.begin() + i);
-      break;
-    }
-  }
-
-  auto &flattenedChildren = child->parent->children;
-  for (int i = flattenedChildren.size() - 1; i >= 0; i--) {
-    if (flattenedChildren[i]->tag == child->tag) {
-      flattenedChildren.erase(flattenedChildren.begin() + i);
-      return;
-    }
-    flattenedChildren[i]->mutation.index--;
-  }
-}
-
-void Node::insertChildren(
-    std::vector<std::shared_ptr<MutationNode>> &newChildren) {
-  mergeAndSwap(children, newChildren);
-}
-
-void Node::insertUnflattenedChildren(
-    std::vector<std::shared_ptr<MutationNode>> &newChildren) {
-  mergeAndSwap(unflattenedChildren, newChildren);
-}
-
-bool Node::isMutationMode() {
-  return false;
-}
-
-bool MutationNode::isMutationMode() {
-  return true;
-}
-} // namespace reanimated
-
-#endif
+#include <reanimated/LayoutAnimations/LayoutAnimationsUtils.h>
+
+#include <memory>
+#include <unordered_map>
+
+namespace reanimated {
+
+std::unordered_map<Tag, UpdateValues> &SurfaceManager::getUpdateMap(SurfaceId surfaceId) {
+  auto props = props_.find(surfaceId);
+  if (props != props_.end()) {
+    return *props->second;
+  }
+
+  auto newProps = std::make_shared<std::unordered_map<Tag, UpdateValues>>();
+  props_.insert_or_assign(surfaceId, newProps);
+  return *newProps;
+}
+
+void SurfaceManager::updateWindow(const SurfaceId surfaceId, const double windowWidth, const double windowHeight) {
+  windows_.insert_or_assign(surfaceId, Rect{windowWidth, windowHeight});
+}
+
+Rect SurfaceManager::getWindow(SurfaceId surfaceId) {
+  auto windowIt = windows_.find(surfaceId);
+  if (windowIt != windows_.end()) {
+    return windowIt->second;
+  }
+  return Rect{0, 0};
+}
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsUtils.h

@@ -1,176 +1,146 @@
-#pragma once
-
-#include <reanimated/Fabric/PropsRegistry.h>
-#include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
-
-#include <react/renderer/mounting/MountingOverrideDelegate.h>
-#include <react/renderer/mounting/ShadowView.h>
-
-#include <memory>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-namespace reanimated {
-
-struct Rect {
-  double width, height;
-};
-
-struct Frame {
-  std::optional<double> x, y, width, height;
-  Frame(jsi::Runtime &runtime, const jsi::Object &newStyle) {
-    if (newStyle.hasProperty(runtime, "originX")) {
-      x = newStyle.getProperty(runtime, "originX").asNumber();
-    }
-    if (newStyle.hasProperty(runtime, "originY")) {
-      y = newStyle.getProperty(runtime, "originY").asNumber();
-    }
-    if (newStyle.hasProperty(runtime, "width")) {
-      width = newStyle.getProperty(runtime, "width").asNumber();
-    }
-    if (newStyle.hasProperty(runtime, "height")) {
-      height = newStyle.getProperty(runtime, "height").asNumber();
-    }
-  }
-};
-
-struct UpdateValues {
-  Props::Shared newProps;
-  Frame frame;
-};
-
-struct Snapshot {
-  double x, y, width, height, windowWidth, windowHeight;
-  Snapshot(const ShadowView &shadowView, Rect window) {
-    const auto &frame = shadowView.layoutMetrics.frame;
-    x = frame.origin.x;
-    y = frame.origin.y;
-    width = frame.size.width;
-    height = frame.size.height;
-    windowWidth = window.width;
-    windowHeight = window.height;
-  }
-};
-
-typedef enum ExitingState {
-  UNDEFINED = 1,
-  WAITING = 2,
-  ANIMATING = 4,
-  DEAD = 8,
-  MOVED = 16,
-  DELETED = 32,
-} ExitingState;
-
-struct MutationNode;
-
-/**
- Represents a view that was either removed or had a child removed from the
- ShadowTree
- */
-struct Node {
-  std::vector<std::shared_ptr<MutationNode>> children, unflattenedChildren;
-  std::shared_ptr<Node> parent, unflattenedParent;
-  Tag tag;
-  void removeChildFromUnflattenedTree(std::shared_ptr<MutationNode> child);
-  void applyMutationToIndices(ShadowViewMutation mutation);
-  void insertChildren(std::vector<std::shared_ptr<MutationNode>> &newChildren);
-  void insertUnflattenedChildren(
-      std::vector<std::shared_ptr<MutationNode>> &newChildren);
-  virtual bool isMutationMode();
-  explicit Node(const Tag tag) : tag(tag) {}
-  Node(Node &&node)
-      : children(std::move(node.children)),
-        unflattenedChildren(std::move(node.unflattenedChildren)),
-        tag(node.tag) {}
-  Node(Node &node)
-      : children(node.children),
-        unflattenedChildren(node.unflattenedChildren),
-        tag(node.tag) {}
-  virtual ~Node() = default;
-};
-
-/**
- Represents a view that was removed from the ShadowTree
- */
-struct MutationNode : public Node {
-  ShadowViewMutation mutation;
-  ExitingState state = UNDEFINED;
-  explicit MutationNode(ShadowViewMutation &mutation)
-      : Node(mutation.oldChildShadowView.tag), mutation(mutation) {}
-  MutationNode(ShadowViewMutation &mutation, Node &&node)
-      : Node(std::move(node)), mutation(mutation) {}
-  bool isMutationMode() override;
-};
-
-struct SurfaceManager {
-  mutable std::unordered_map<
-      SurfaceId,
-      std::shared_ptr<std::unordered_map<Tag, UpdateValues>>>
-      props_;
-  mutable std::unordered_map<SurfaceId, Rect> windows_;
-
-  std::unordered_map<Tag, UpdateValues> &getUpdateMap(SurfaceId surfaceId);
-  void
-  updateWindow(SurfaceId surfaceId, double windowWidth, double windowHeight);
-  Rect getWindow(SurfaceId surfaceId);
-};
-
-static inline void updateLayoutMetrics(
-    LayoutMetrics &layoutMetrics,
-    Frame &frame) {
-  // we use optional's here to avoid overwriting non-animated values
-  if (frame.width) {
-    layoutMetrics.frame.size.width = *frame.width;
-  }
-  if (frame.height) {
-    layoutMetrics.frame.size.height = *frame.height;
-  }
-  if (frame.x) {
-    layoutMetrics.frame.origin.x = *frame.x;
-  }
-  if (frame.y) {
-    layoutMetrics.frame.origin.y = *frame.y;
-  }
-}
-
-static inline bool isRNSScreen(std::shared_ptr<MutationNode> node) {
-  return !std::strcmp(
-             node->mutation.oldChildShadowView.componentName,
-             "RNSScreenStack") ||
-      !std::strcmp(
-          node->mutation.oldChildShadowView.componentName, "RNSScreen");
-}
-
-static inline bool hasLayoutChanged(const ShadowViewMutation &mutation) {
-  return mutation.oldChildShadowView.layoutMetrics.frame !=
-      mutation.newChildShadowView.layoutMetrics.frame;
-}
-
-static inline void mergeAndSwap(
-    std::vector<std::shared_ptr<MutationNode>> &A,
-    std::vector<std::shared_ptr<MutationNode>> &B) {
-  std::vector<std::shared_ptr<MutationNode>> merged;
-  auto it1 = A.begin(), it2 = B.begin();
-  while (it1 != A.end() && it2 != B.end()) {
-    if ((*it1)->mutation.index < (*it2)->mutation.index) {
-      merged.push_back(*it1);
-      it1++;
-    } else {
-      merged.push_back(*it2);
-      it2++;
-    }
-  }
-  while (it1 != A.end()) {
-    merged.push_back(*it1);
-    it1++;
-  }
-  while (it2 != B.end()) {
-    merged.push_back(*it2);
-    it2++;
-  }
-  std::swap(A, merged);
-}
-
-} // namespace reanimated
+#pragma once
+
+#include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
+
+#include <react/renderer/mounting/MountingOverrideDelegate.h>
+#include <react/renderer/mounting/ShadowView.h>
+
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace reanimated {
+
+enum BeforeOrAfter { BEFORE = 0, AFTER = 1 };
+
+struct Rect {
+  double width, height;
+};
+
+struct Frame {
+  std::optional<double> x, y, width, height;
+  Frame(double x, double y, double width, double height) : x(x), y(y), width(width), height(height) {}
+  Frame(jsi::Runtime &runtime, const jsi::Object &newStyle) {
+    if (newStyle.hasProperty(runtime, "originX")) {
+      x = newStyle.getProperty(runtime, "originX").asNumber();
+    }
+    if (newStyle.hasProperty(runtime, "originY")) {
+      y = newStyle.getProperty(runtime, "originY").asNumber();
+    }
+    if (newStyle.hasProperty(runtime, "width")) {
+      width = newStyle.getProperty(runtime, "width").asNumber();
+    }
+    if (newStyle.hasProperty(runtime, "height")) {
+      height = newStyle.getProperty(runtime, "height").asNumber();
+    }
+  }
+};
+
+struct UpdateValues {
+  Props::Shared newProps;
+  Frame frame;
+};
+
+struct Snapshot {
+  double x, y, width, height, windowWidth, windowHeight;
+  Snapshot(const ShadowView &shadowView, Rect window) {
+    const auto &frame = shadowView.layoutMetrics.frame;
+    x = frame.origin.x;
+    y = frame.origin.y;
+    width = frame.size.width;
+    height = frame.size.height;
+    windowWidth = window.width;
+    windowHeight = window.height;
+  }
+};
+
+typedef enum class ExitingState : std::uint8_t {
+  UNDEFINED = 1,
+  WAITING = 2,
+  ANIMATING = 3,
+  DEAD = 4,
+  DELETED = 5,
+} ExitingState;
+
+struct MutationNode;
+
+enum TransitionState {
+  NONE = 0,
+  START = 1,
+  ACTIVE = 2,
+  END = 3,
+  CANCELLED = 4,
+};
+
+enum Intent {
+  NO_INTENT = 0,
+  TO_MOVE = 1,
+  TO_DELETE = 2,
+};
+
+struct LightNode {
+  ShadowView previous;
+  ShadowView current;
+  ExitingState state = ExitingState::UNDEFINED;
+  std::weak_ptr<LightNode> parent;
+  std::vector<std::shared_ptr<LightNode>> children;
+  int removeChild(std::shared_ptr<LightNode> child) {
+    for (int i = children.size() - 1; i >= 0; i--) {
+      if (children[i]->current.tag == child->current.tag) {
+        children.erase(children.begin() + i);
+        return i;
+      }
+    }
+    return -1;
+  }
+};
+
+struct SurfaceManager {
+  mutable std::unordered_map<SurfaceId, std::shared_ptr<std::unordered_map<Tag, UpdateValues>>> props_;
+  mutable std::unordered_map<SurfaceId, Rect> windows_;
+
+  std::unordered_map<Tag, UpdateValues> &getUpdateMap(SurfaceId surfaceId);
+  void updateWindow(SurfaceId surfaceId, double windowWidth, double windowHeight);
+  Rect getWindow(SurfaceId surfaceId);
+};
+
+static inline void updateLayoutMetrics(LayoutMetrics &layoutMetrics, const Frame &frame) {
+  // we use optional's here to avoid overwriting non-animated values
+  if (frame.width) {
+    layoutMetrics.frame.size.width = *frame.width;
+  }
+  if (frame.height) {
+    layoutMetrics.frame.size.height = *frame.height;
+  }
+  if (frame.x) {
+    layoutMetrics.frame.origin.x = *frame.x;
+  }
+  if (frame.y) {
+    layoutMetrics.frame.origin.y = *frame.y;
+  }
+}
+
+static inline bool isRNSScreenOrStack(const std::shared_ptr<LightNode> &node) {
+  const auto componentName = node->current.componentName;
+  react_native_assert(componentName && "Component name is nullptr");
+  return !std::strcmp(componentName, "RNSScreenStack") || !std::strcmp(componentName, "RNSScreen") ||
+      !std::strcmp(componentName, "RNSModalScreen");
+}
+
+static inline bool isRNSScreen(const std::shared_ptr<LightNode> &node) {
+  const auto componentName = node->current.componentName;
+  react_native_assert(componentName && "Component name is nullptr");
+  return !std::strcmp(componentName, "RNSScreen") || !std::strcmp(componentName, "RNSModalScreen");
+}
+
+static inline bool isRoot(const std::shared_ptr<LightNode> &node) {
+  return node->current.tag % 10 == 1;
+}
+
+static inline bool hasLayoutChanged(const ShadowViewMutation &mutation) {
+  return mutation.oldChildShadowView.layoutMetrics.frame != mutation.newChildShadowView.layoutMetrics.frame;
+}
+
+} // namespace reanimated