@react-native-ohos/react-native-reanimated 3.18.1-rc.6 → 4.0.0-rc.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/LayoutAnimations/{LayoutAnimationsProxy.cpp → LayoutAnimationsProxy_Legacy.cpp}

@@ -1,13 +1,17 @@
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <reanimated/LayoutAnimations/LayoutAnimationsProxy.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsProxy_Legacy.h>
 #include <reanimated/NativeModules/ReanimatedModuleProxy.h>
 
 #include <react/renderer/animations/utils.h>
 #include <react/renderer/mounting/ShadowViewMutation.h>
 
+#include <memory>
+#include <ranges>
 #include <set>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
 #include <utility>
+#include <vector>
 
 namespace reanimated {
 
@@ -18,39 +22,49 @@ namespace reanimated {
 // On android this code will be sometimes executed on the JS thread.
 // That's why we have to schedule some of animation manager function on the UI
 // thread
-std::optional<MountingTransaction> LayoutAnimationsProxy::pullTransaction(
+std::optional<MountingTransaction> LayoutAnimationsProxy_Legacy::pullTransaction(
     SurfaceId surfaceId,
     MountingTransaction::Number transactionNumber,
     const TransactionTelemetry &telemetry,
     ShadowViewMutationList mutations) const {
 #ifdef LAYOUT_ANIMATIONS_LOGS
   LOG(INFO) << std::endl;
-  LOG(INFO) << "pullTransaction " << std::this_thread::get_id() << " "
-            << surfaceId << std::endl;
+  LOG(INFO) << "pullTransaction " << std::this_thread::get_id() << " " << surfaceId << std::endl;
 #endif
   auto lock = std::unique_lock<std::recursive_mutex>(mutex);
   PropsParserContext propsParserContext{surfaceId, *contextContainer_};
   ShadowViewMutationList filteredMutations;
+  auto &[deadNodes] = surfaceContext_[surfaceId];
 
   std::vector<std::shared_ptr<MutationNode>> roots;
-  std::unordered_map<Tag, ShadowView> movedViews;
+  std::unordered_map<Tag, Tag> movedViews;
+
+  addOngoingAnimations(surfaceId, filteredMutations);
+
+#ifdef ANDROID
+  restoreOpacityInCaseOfFlakyEnteringAnimation(surfaceId);
+#endif // ANDROID
+  for (const auto tag : finishedAnimationTags_) {
+    auto &updateMap = surfaceManager.getUpdateMap(surfaceId);
+    layoutAnimations_.erase(tag);
+    updateMap.erase(tag);
+  }
+  finishedAnimationTags_.clear();
 
   parseRemoveMutations(movedViews, mutations, roots);
 
-  handleRemovals(filteredMutations, roots);
+  auto shouldAnimate = !surfacesToRemove_.contains(surfaceId);
+  surfacesToRemove_.erase(surfaceId);
+  handleRemovals(filteredMutations, roots, deadNodes, shouldAnimate);
 
-  handleUpdatesAndEnterings(
-      filteredMutations, movedViews, mutations, propsParserContext, surfaceId);
+  handleUpdatesAndEnterings(filteredMutations, movedViews, mutations, propsParserContext, surfaceId);
 
   addOngoingAnimations(surfaceId, filteredMutations);
 
-  return MountingTransaction{
-      surfaceId, transactionNumber, std::move(filteredMutations), telemetry};
+  return MountingTransaction{surfaceId, transactionNumber, std::move(filteredMutations), telemetry};
 }
 
-std::optional<SurfaceId> LayoutAnimationsProxy::progressLayoutAnimation(
-    int tag,
-    const jsi::Object &newStyle) {
+std::optional<SurfaceId> LayoutAnimationsProxy_Legacy::progressLayoutAnimation(int tag, const jsi::Object &newStyle) {
 #ifdef LAYOUT_ANIMATIONS_LOGS
   LOG(INFO) << "progress layout animation for tag " << tag << std::endl;
 #endif
@@ -65,35 +79,24 @@ std::optional<SurfaceId> LayoutAnimationsProxy::progressLayoutAnimation(
 
   maybeRestoreOpacity(layoutAnimation, newStyle);
 
-  auto rawProps =
-      std::make_shared<RawProps>(uiRuntime_, jsi::Value(uiRuntime_, newStyle));
+  auto rawProps = std::make_shared<RawProps>(uiRuntime_, jsi::Value(uiRuntime_, newStyle));
 
-  PropsParserContext propsParserContext{
-      layoutAnimation.finalView->surfaceId, *contextContainer_};
-#ifdef ANDROID
-  rawProps = std::make_shared<RawProps>(folly::dynamic::merge(
-      layoutAnimation.finalView->props->rawProps, (folly::dynamic)*rawProps));
+  PropsParserContext propsParserContext{layoutAnimation.finalView.surfaceId, *contextContainer_};
+#ifdef RN_SERIALIZABLE_STATE
+  rawProps = std::make_shared<RawProps>(
+      folly::dynamic::merge(layoutAnimation.finalView.props->rawProps, (folly::dynamic)*rawProps));
 #endif
-  auto newProps =
-      getComponentDescriptorForShadowView(*layoutAnimation.finalView)
-          .cloneProps(
-              propsParserContext,
-              layoutAnimation.finalView->props,
-              std::move(*rawProps));
-  auto &updateMap =
-      surfaceManager.getUpdateMap(layoutAnimation.finalView->surfaceId);
-  updateMap.insert_or_assign(
-      tag, UpdateValues{newProps, Frame(uiRuntime_, newStyle)});
-
-  return layoutAnimation.finalView->surfaceId;
+  auto newProps = getComponentDescriptorForShadowView(layoutAnimation.finalView)
+                      .cloneProps(propsParserContext, layoutAnimation.finalView.props, std::move(*rawProps));
+  auto &updateMap = surfaceManager.getUpdateMap(layoutAnimation.finalView.surfaceId);
+  updateMap.insert_or_assign(tag, UpdateValues{newProps, Frame(uiRuntime_, newStyle)});
+
+  return layoutAnimation.finalView.surfaceId;
 }
 
-std::optional<SurfaceId> LayoutAnimationsProxy::endLayoutAnimation(
-    int tag,
-    bool shouldRemove) {
+std::optional<SurfaceId> LayoutAnimationsProxy_Legacy::endLayoutAnimation(int tag, bool shouldRemove) {
 #ifdef LAYOUT_ANIMATIONS_LOGS
-  LOG(INFO) << "end layout animation for " << tag << " - should remove "
-            << shouldRemove << std::endl;
+  LOG(INFO) << "end layout animation for " << tag << " - should remove " << shouldRemove << std::endl;
 #endif
   auto lock = std::unique_lock<std::recursive_mutex>(mutex);
   auto layoutAnimationIt = layoutAnimations_.find(tag);
@@ -112,11 +115,8 @@ std::optional<SurfaceId> LayoutAnimationsProxy::endLayoutAnimation(
     layoutAnimation.count--;
     return {};
   }
-
-  auto surfaceId = layoutAnimation.finalView->surfaceId;
-  auto &updateMap = surfaceManager.getUpdateMap(surfaceId);
-  layoutAnimations_.erase(tag);
-  updateMap.erase(tag);
+  finishedAnimationTags_.push_back(tag);
+  auto surfaceId = layoutAnimation.finalView.surfaceId;
 
   if (!shouldRemove || !nodeForTag_.contains(tag)) {
     return {};
@@ -125,6 +125,7 @@ std::optional<SurfaceId> LayoutAnimationsProxy::endLayoutAnimation(
   auto node = nodeForTag_[tag];
   auto mutationNode = std::static_pointer_cast<MutationNode>(node);
   mutationNode->state = DEAD;
+  auto &[deadNodes] = surfaceContext_[surfaceId];
   deadNodes.insert(mutationNode);
 
   return surfaceId;
@@ -134,13 +135,12 @@ std::optional<SurfaceId> LayoutAnimationsProxy::endLayoutAnimation(
  Organizes removed views into a tree structure, allowing for convenient
  traversals and index maintenance
  */
-void LayoutAnimationsProxy::parseRemoveMutations(
-    std::unordered_map<Tag, ShadowView> &movedViews,
+void LayoutAnimationsProxy_Legacy::parseRemoveMutations(
+    std::unordered_map<Tag, Tag> &movedViews,
     ShadowViewMutationList &mutations,
     std::vector<std::shared_ptr<MutationNode>> &roots) const {
   std::set<Tag> deletedViews;
-  std::unordered_map<Tag, std::vector<std::shared_ptr<MutationNode>>>
-      childrenForTag, unflattenedChildrenForTag;
+  std::unordered_map<Tag, std::vector<std::shared_ptr<MutationNode>>> childrenForTag, unflattenedChildrenForTag;
 
   std::vector<std::shared_ptr<MutationNode>> mutationNodes;
 
@@ -153,24 +153,17 @@ void LayoutAnimationsProxy::parseRemoveMutations(
     if (mutation.type == ShadowViewMutation::Remove) {
       updateIndexForMutation(mutation);
       auto tag = mutation.oldChildShadowView.tag;
-#if REACT_NATIVE_MINOR_VERSION >= 78
       auto parentTag = mutation.parentTag;
-#else
-      auto parentTag = mutation.parentShadowView.tag;
-#endif // REACT_NATIVE_MINOR_VERSION >= 78
       auto unflattenedParentTag = parentTag; // temporary
 
       std::shared_ptr<MutationNode> mutationNode;
-      std::shared_ptr<Node> node = nodeForTag_[tag],
-                            parent = nodeForTag_[parentTag],
-                            unflattenedParent =
-                                nodeForTag_[unflattenedParentTag];
+      std::shared_ptr<Node> node = nodeForTag_[tag], parent = nodeForTag_[parentTag],
+                            unflattenedParent = nodeForTag_[unflattenedParentTag];
 
       if (!node) {
         mutationNode = std::make_shared<MutationNode>(mutation);
       } else {
-        mutationNode =
-            std::make_shared<MutationNode>(mutation, std::move(*node));
+        mutationNode = std::make_shared<MutationNode>(mutation, std::move(*node));
         for (auto &subNode : mutationNode->children) {
           subNode->parent = mutationNode;
         }
@@ -180,8 +173,7 @@ void LayoutAnimationsProxy::parseRemoveMutations(
       }
       if (!deletedViews.contains(mutation.oldChildShadowView.tag)) {
         mutationNode->state = MOVED;
-        movedViews.insert_or_assign(
-            mutation.oldChildShadowView.tag, mutation.oldChildShadowView);
+        movedViews.insert_or_assign(mutation.oldChildShadowView.tag, -1);
       }
       nodeForTag_[tag] = mutationNode;
 
@@ -206,12 +198,16 @@ void LayoutAnimationsProxy::parseRemoveMutations(
       mutationNode->parent = parent;
       mutationNode->unflattenedParent = unflattenedParent;
     }
-    if (mutation.type == ShadowViewMutation::Update &&
-        movedViews.contains(mutation.newChildShadowView.tag)) {
+    if (mutation.type == ShadowViewMutation::Update && movedViews.contains(mutation.newChildShadowView.tag)) {
       auto node = nodeForTag_[mutation.newChildShadowView.tag];
       auto mutationNode = std::static_pointer_cast<MutationNode>(node);
       mutationNode->mutation.oldChildShadowView = mutation.oldChildShadowView;
-      movedViews[mutation.newChildShadowView.tag] = mutation.oldChildShadowView;
+    }
+  }
+
+  for (const auto &mutation : mutations) {
+    if (mutation.type == ShadowViewMutation::Insert && movedViews.contains(mutation.newChildShadowView.tag)) {
+      movedViews[mutation.newChildShadowView.tag] = mutation.parentTag;
     }
   }
 
@@ -231,28 +227,29 @@ void LayoutAnimationsProxy::parseRemoveMutations(
   }
 
   for (auto &mutationNode : mutationNodes) {
-    if (!mutationNode->unflattenedParent->isMutationMode()) {
+    if (!mutationNode->unflattenedParent->isMutationNode()) {
       roots.push_back(mutationNode);
     }
   }
 }
 
-void LayoutAnimationsProxy::handleRemovals(
+void LayoutAnimationsProxy_Legacy::handleRemovals(
     ShadowViewMutationList &filteredMutations,
-    std::vector<std::shared_ptr<MutationNode>> &roots) const {
+    std::vector<std::shared_ptr<MutationNode>> &roots,
+    std::unordered_set<std::shared_ptr<MutationNode>> &deadNodes,
+    bool shouldAnimate) const {
   // iterate from the end, so that children
   // with higher indices appear first in the mutations list
   for (auto it = roots.rbegin(); it != roots.rend(); it++) {
     auto &node = *it;
-    if (!startAnimationsRecursively(
-            node, true, true, false, filteredMutations)) {
+    if (!startAnimationsRecursively(node, true, shouldAnimate, false, filteredMutations)) {
       filteredMutations.push_back(node->mutation);
       node->unflattenedParent->removeChildFromUnflattenedTree(node); //???
       if (node->state != MOVED) {
         maybeCancelAnimation(node->tag);
-        filteredMutations.push_back(ShadowViewMutation::DeleteMutation(
-            node->mutation.oldChildShadowView));
+        filteredMutations.push_back(ShadowViewMutation::DeleteMutation(node->mutation.oldChildShadowView));
         nodeForTag_.erase(node->tag);
+        node->state = DELETED;
 #ifdef LAYOUT_ANIMATIONS_LOGS
         LOG(INFO) << "delete " << node->tag << std::endl;
 #endif
@@ -260,7 +257,7 @@ void LayoutAnimationsProxy::handleRemovals(
     }
   }
 
-  for (auto node : deadNodes) {
+  for (const auto &node : deadNodes) {
     if (node->state != DELETED) {
       endAnimationsRecursively(node, filteredMutations);
       maybeDropAncestors(node->unflattenedParent, node, filteredMutations);
@@ -269,9 +266,9 @@ void LayoutAnimationsProxy::handleRemovals(
   deadNodes.clear();
 }
 
-void LayoutAnimationsProxy::handleUpdatesAndEnterings(
+void LayoutAnimationsProxy_Legacy::handleUpdatesAndEnterings(
     ShadowViewMutationList &filteredMutations,
-    const std::unordered_map<Tag, ShadowView> &movedViews,
+    const std::unordered_map<Tag, Tag> &movedViews,
     ShadowViewMutationList &mutations,
     const PropsParserContext &propsParserContext,
     SurfaceId surfaceId) const {
@@ -279,8 +276,7 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
   for (auto &mutation : mutations) {
     maybeUpdateWindowDimensions(mutation, surfaceId);
 
-    Tag tag = mutation.type == ShadowViewMutation::Type::Create ||
-            mutation.type == ShadowViewMutation::Type::Insert
+    Tag tag = mutation.type == ShadowViewMutation::Type::Create || mutation.type == ShadowViewMutation::Type::Insert
         ? mutation.newChildShadowView.tag
         : mutation.oldChildShadowView.tag;
 
@@ -292,13 +288,8 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
       case ShadowViewMutation::Type::Insert: {
         updateIndexForMutation(mutation);
 
-#if REACT_NATIVE_MINOR_VERSION >= 78
         const auto parentTag = mutation.parentTag;
         const auto mutationParent = parentTag;
-#else
-        const auto parentTag = mutation.parentShadowView.tag;
-        const auto mutationParent = mutation.parentShadowView;
-#endif // REACT_NATIVE_MINOR_VERSION >= 78
         if (nodeForTag_.contains(parentTag)) {
           nodeForTag_[parentTag]->applyMutationToIndices(mutation);
         }
@@ -308,25 +299,23 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
           if (layoutAnimationIt == layoutAnimations_.end()) {
             if (oldShadowViewsForReparentings.contains(tag)) {
               filteredMutations.push_back(ShadowViewMutation::InsertMutation(
-                  mutationParent,
-                  oldShadowViewsForReparentings[tag],
-                  mutation.index));
+                  mutationParent, oldShadowViewsForReparentings[tag], mutation.index));
             } else {
               filteredMutations.push_back(mutation);
             }
             continue;
           }
 
-          auto oldView = *layoutAnimationIt->second.currentView;
-          filteredMutations.push_back(ShadowViewMutation::InsertMutation(
-              mutationParent, oldView, mutation.index));
+          auto oldView = layoutAnimationIt->second.currentView;
+          filteredMutations.push_back(ShadowViewMutation::InsertMutation(mutationParent, oldView, mutation.index));
+          if (movedViews.contains(tag)) {
+            layoutAnimationIt->second.parentTag = movedViews.at(tag);
+          }
           continue;
         }
 
-        transferConfigFromNativeID(
-            mutation.newChildShadowView.props->nativeId,
-            mutation.newChildShadowView.tag);
-        if (!layoutAnimationsManager_->hasLayoutAnimation(tag, ENTERING)) {
+        transferConfigFromNativeID(mutation.newChildShadowView.props->nativeId, mutation.newChildShadowView.tag);
+        if (!layoutAnimationsManager_->hasLayoutAnimation(tag, LayoutAnimationType::ENTERING)) {
           filteredMutations.push_back(mutation);
           continue;
         }
@@ -335,17 +324,16 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
         filteredMutations.push_back(mutation);
 
         // temporarily set opacity to 0 to prevent flickering on android
-        std::shared_ptr<ShadowView> newView =
-            cloneViewWithoutOpacity(mutation, propsParserContext);
+        std::shared_ptr<ShadowView> newView = cloneViewWithoutOpacity(mutation, propsParserContext);
 
-        filteredMutations.push_back(ShadowViewMutation::UpdateMutation(
-            mutation.newChildShadowView, *newView, mutationParent));
+        filteredMutations.push_back(
+            ShadowViewMutation::UpdateMutation(mutation.newChildShadowView, *newView, mutationParent));
         break;
       }
 
       case ShadowViewMutation::Type::Update: {
         auto shouldAnimate = hasLayoutChanged(mutation);
-        if (!layoutAnimationsManager_->hasLayoutAnimation(tag, LAYOUT) ||
+        if (!layoutAnimationsManager_->hasLayoutAnimation(tag, LayoutAnimationType::LAYOUT) ||
             (!shouldAnimate && !layoutAnimations_.contains(tag))) {
           // We should cancel any ongoing animation here to ensure that the
           // proper final state is reached for this view However, due to how
@@ -364,7 +352,12 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
         // store the oldChildShadowView, so that we can use this ShadowView when
         // the view is inserted
         oldShadowViewsForReparentings[tag] = mutation.oldChildShadowView;
-        startLayoutAnimation(tag, mutation);
+        if (movedViews.contains(tag)) {
+          mutation.parentTag = movedViews.at(tag);
+        }
+        if (mutation.parentTag != -1) {
+          startLayoutAnimation(tag, mutation);
+        }
         break;
       }
 
@@ -379,11 +372,40 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
   }
 }
 
-void LayoutAnimationsProxy::addOngoingAnimations(
-    SurfaceId surfaceId,
-    ShadowViewMutationList &mutations) const {
+void LayoutAnimationsProxy_Legacy::addOngoingAnimations(SurfaceId surfaceId, ShadowViewMutationList &mutations) const {
   auto &updateMap = surfaceManager.getUpdateMap(surfaceId);
+#ifdef ANDROID
+  std::vector<int> tagsToUpdate;
+  tagsToUpdate.reserve(updateMap.size());
+
+  for (auto &[tag, updateValues] : updateMap) {
+    tagsToUpdate.push_back(tag);
+  }
+
+  auto maybeCorrectedTags = preserveMountedTags_(tagsToUpdate);
+  if (!maybeCorrectedTags.has_value()) {
+    return;
+  }
+
+  auto correctedTags = maybeCorrectedTags->get();
+
+  // since the map is not updated, we can assume that the ordering of tags in
+  // correctedTags matches the iterator
+  int i = -1;
+#endif
   for (auto &[tag, updateValues] : updateMap) {
+#ifdef ANDROID
+    i++;
+    if (correctedTags[i] == -1) {
+      // skip views that have not been mounted yet
+      // on Android we start entering animations from the JS thread
+      // so it might happen, that the first frame of the animation goes through
+      // before the view is first mounted
+      // https://github.com/software-mansion/react-native-reanimated/issues/7493
+      continue;
+    }
+#endif
+
     auto layoutAnimationIt = layoutAnimations_.find(tag);
 
     if (layoutAnimationIt == layoutAnimations_.end()) {
@@ -391,35 +413,26 @@ void LayoutAnimationsProxy::addOngoingAnimations(
     }
 
     auto &layoutAnimation = layoutAnimationIt->second;
+    layoutAnimation.isViewAlreadyMounted = true;
+    auto newView = layoutAnimation.finalView;
+    newView.props = updateValues.newProps;
+    updateLayoutMetrics(newView.layoutMetrics, updateValues.frame);
 
-    auto newView = std::make_shared<ShadowView>(*layoutAnimation.finalView);
-    newView->props = updateValues.newProps;
-    updateLayoutMetrics(newView->layoutMetrics, updateValues.frame);
-
-    mutations.push_back(ShadowViewMutation::UpdateMutation(
-        *layoutAnimation.currentView,
-        *newView,
-#if REACT_NATIVE_MINOR_VERSION >= 78
-        layoutAnimation.parentTag
-#else
-        *layoutAnimation.parentView
-#endif // REACT_NATIVE_MINOR_VERSION >= 78
-        ));
+    mutations.push_back(
+        ShadowViewMutation::UpdateMutation(layoutAnimation.currentView, newView, layoutAnimation.parentTag));
     layoutAnimation.currentView = newView;
   }
   updateMap.clear();
 }
 
-void LayoutAnimationsProxy::endAnimationsRecursively(
-    std::shared_ptr<MutationNode> node,
+void LayoutAnimationsProxy_Legacy::endAnimationsRecursively(
+    const std::shared_ptr<MutationNode> &node,
     ShadowViewMutationList &mutations) const {
   maybeCancelAnimation(node->tag);
   node->state = DELETED;
   // iterate from the end, so that children
   // with higher indices appear first in the mutations list
-  for (auto it = node->unflattenedChildren.rbegin();
-       it != node->unflattenedChildren.rend();
-       it++) {
+  for (auto it = node->unflattenedChildren.rbegin(); it != node->unflattenedChildren.rend(); it++) {
     auto &subNode = *it;
     if (subNode->state != DELETED) {
       endAnimationsRecursively(subNode, mutations);
@@ -430,16 +443,15 @@ void LayoutAnimationsProxy::endAnimationsRecursively(
 #ifdef LAYOUT_ANIMATIONS_LOGS
   LOG(INFO) << "delete " << node->tag << std::endl;
 #endif
-  mutations.push_back(
-      ShadowViewMutation::DeleteMutation(node->mutation.oldChildShadowView));
+  mutations.push_back(ShadowViewMutation::DeleteMutation(node->mutation.oldChildShadowView));
 }
 
-void LayoutAnimationsProxy::maybeDropAncestors(
-    std::shared_ptr<Node> parent,
-    std::shared_ptr<MutationNode> child,
+void LayoutAnimationsProxy_Legacy::maybeDropAncestors(
+    const std::shared_ptr<Node> &parent,
+    const std::shared_ptr<MutationNode> &child,
     ShadowViewMutationList &cleanupMutations) const {
   parent->removeChildFromUnflattenedTree(child);
-  if (!parent->isMutationMode()) {
+  if (!parent->isMutationNode()) {
     return;
   }
 
@@ -449,23 +461,22 @@ void LayoutAnimationsProxy::maybeDropAncestors(
     nodeForTag_.erase(node->tag);
     cleanupMutations.push_back(node->mutation);
     maybeCancelAnimation(node->tag);
+    node->state = DELETED;
 #ifdef LAYOUT_ANIMATIONS_LOGS
     LOG(INFO) << "delete " << node->tag << std::endl;
 #endif
-    cleanupMutations.push_back(
-        ShadowViewMutation::DeleteMutation(node->mutation.oldChildShadowView));
+    cleanupMutations.push_back(ShadowViewMutation::DeleteMutation(node->mutation.oldChildShadowView));
     maybeDropAncestors(node->unflattenedParent, node, cleanupMutations);
   }
 }
 
-const ComponentDescriptor &
-LayoutAnimationsProxy::getComponentDescriptorForShadowView(
+const ComponentDescriptor &LayoutAnimationsProxy_Legacy::getComponentDescriptorForShadowView(
     const ShadowView &shadowView) const {
   return componentDescriptorRegistry_->at(shadowView.componentHandle);
 }
 
-bool LayoutAnimationsProxy::startAnimationsRecursively(
-    std::shared_ptr<MutationNode> node,
+bool LayoutAnimationsProxy_Legacy::startAnimationsRecursively(
+    const std::shared_ptr<MutationNode> &node,
     bool shouldRemoveSubviewsWithoutAnimations,
     bool shouldAnimate,
     bool isScreenPop,
@@ -474,28 +485,23 @@ bool LayoutAnimationsProxy::startAnimationsRecursively(
     isScreenPop = true;
   }
 
-  shouldAnimate = !isScreenPop &&
-      layoutAnimationsManager_->shouldAnimateExiting(node->tag, shouldAnimate);
+  shouldAnimate = !isScreenPop && layoutAnimationsManager_->shouldAnimateExiting(node->tag, shouldAnimate);
 
-  bool hasExitAnimation = shouldAnimate &&
-      layoutAnimationsManager_->hasLayoutAnimation(
-          node->tag, LayoutAnimationType::EXITING);
+  bool hasExitAnimation =
+      shouldAnimate && layoutAnimationsManager_->hasLayoutAnimation(node->tag, LayoutAnimationType::EXITING);
   bool hasAnimatedChildren = false;
 
   shouldRemoveSubviewsWithoutAnimations =
-      shouldRemoveSubviewsWithoutAnimations && !hasExitAnimation;
+      shouldRemoveSubviewsWithoutAnimations && (!hasExitAnimation || node->state == MOVED);
   std::vector<std::shared_ptr<MutationNode>> toBeRemoved;
 
   // iterate from the end, so that children
   // with higher indices appear first in the mutations list
-  for (auto it = node->unflattenedChildren.rbegin();
-       it != node->unflattenedChildren.rend();
-       it++) {
+  for (auto it = node->unflattenedChildren.rbegin(); it != node->unflattenedChildren.rend(); it++) {
     auto &subNode = *it;
 #ifdef LAYOUT_ANIMATIONS_LOGS
     LOG(INFO) << "child " << subNode->tag << " "
-              << " " << shouldAnimate << " "
-              << shouldRemoveSubviewsWithoutAnimations << std::endl;
+              << " " << shouldAnimate << " " << shouldRemoveSubviewsWithoutAnimations << std::endl;
 #endif
     if (subNode->state != UNDEFINED && subNode->state != MOVED) {
       if (shouldAnimate && subNode->state != DEAD) {
@@ -505,14 +511,9 @@ bool LayoutAnimationsProxy::startAnimationsRecursively(
         toBeRemoved.push_back(subNode);
       }
     } else if (startAnimationsRecursively(
-                   subNode,
-                   shouldRemoveSubviewsWithoutAnimations,
-                   shouldAnimate,
-                   isScreenPop,
-                   mutations)) {
+                   subNode, shouldRemoveSubviewsWithoutAnimations, shouldAnimate, isScreenPop, mutations)) {
 #ifdef LAYOUT_ANIMATIONS_LOGS
-      LOG(INFO) << "child " << subNode->tag
-                << " start animations returned true " << std::endl;
+      LOG(INFO) << "child " << subNode->tag << " start animations returned true " << std::endl;
 #endif
       hasAnimatedChildren = true;
     } else if (subNode->state == MOVED) {
@@ -527,8 +528,7 @@ bool LayoutAnimationsProxy::startAnimationsRecursively(
 #ifdef LAYOUT_ANIMATIONS_LOGS
       LOG(INFO) << "delete " << subNode->tag << std::endl;
 #endif
-      mutations.push_back(ShadowViewMutation::DeleteMutation(
-          subNode->mutation.oldChildShadowView));
+      mutations.push_back(ShadowViewMutation::DeleteMutation(subNode->mutation.oldChildShadowView));
     } else {
       subNode->state = WAITING;
     }
@@ -540,10 +540,10 @@ bool LayoutAnimationsProxy::startAnimationsRecursively(
 
   if (node->state == MOVED) {
     auto replacement = std::make_shared<Node>(*node);
-    for (auto subNode : node->children) {
+    for (const auto &subNode : node->children) {
       subNode->parent = replacement;
     }
-    for (auto subNode : node->unflattenedChildren) {
+    for (const auto &subNode : node->unflattenedChildren) {
       subNode->unflattenedParent = replacement;
     }
     nodeForTag_[replacement->tag] = replacement;
@@ -562,17 +562,12 @@ bool LayoutAnimationsProxy::startAnimationsRecursively(
   return wantAnimateExit;
 }
 
-void LayoutAnimationsProxy::updateIndexForMutation(
-    ShadowViewMutation &mutation) const {
+void LayoutAnimationsProxy_Legacy::updateIndexForMutation(ShadowViewMutation &mutation) const {
   if (mutation.index == -1) {
     return;
   }
 
-#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 (!nodeForTag_.contains(parentTag)) {
     return;
@@ -590,20 +585,19 @@ void LayoutAnimationsProxy::updateIndexForMutation(
     prevIndex = subNode->mutation.index;
   }
 #ifdef LAYOUT_ANIMATIONS_LOGS
-  int tag = mutation.type == ShadowViewMutation::Insert
-      ? mutation.newChildShadowView.tag
-      : mutation.oldChildShadowView.tag;
-  LOG(INFO) << "update index for " << tag << " in " << parentTag << ": "
-            << mutation.index << " -> " << mutation.index + offset << std::endl;
+  int tag =
+      mutation.type == ShadowViewMutation::Insert ? mutation.newChildShadowView.tag : mutation.oldChildShadowView.tag;
+  LOG(INFO) << "update index for " << tag << " in " << parentTag << ": " << mutation.index << " -> "
+            << mutation.index + offset << std::endl;
 #endif
   mutation.index += offset;
 }
 
-bool LayoutAnimationsProxy::shouldOverridePullTransaction() const {
+bool LayoutAnimationsProxy_Legacy::shouldOverridePullTransaction() const {
   return true;
 }
 
-void LayoutAnimationsProxy::createLayoutAnimation(
+void LayoutAnimationsProxy_Legacy::createLayoutAnimation(
     const ShadowViewMutation &mutation,
     ShadowView &oldView,
     const SurfaceId &surfaceId,
@@ -613,52 +607,36 @@ void LayoutAnimationsProxy::createLayoutAnimation(
 
   if (layoutAnimationIt != layoutAnimations_.end()) {
     auto &layoutAnimation = layoutAnimationIt->second;
-    oldView = *layoutAnimation.currentView;
+    oldView = layoutAnimation.currentView;
     count = layoutAnimation.count + 1;
   }
 
-  auto finalView = std::make_shared<ShadowView>(
-      mutation.type == ShadowViewMutation::Remove
-          ? mutation.oldChildShadowView
-          : mutation.newChildShadowView);
-  auto currentView = std::make_shared<ShadowView>(oldView);
+  auto finalView =
+      mutation.type == ShadowViewMutation::Remove ? mutation.oldChildShadowView : mutation.newChildShadowView;
+  auto currentView = oldView;
 
-#if REACT_NATIVE_MINOR_VERSION >= 78
   layoutAnimations_.insert_or_assign(
       tag,
-      LayoutAnimation{finalView, currentView, mutation.parentTag, {}, count});
-#else
-  auto parentView = std::make_shared<ShadowView>(mutation.parentShadowView);
-  layoutAnimations_.insert_or_assign(
-      tag, LayoutAnimation{finalView, currentView, parentView, {}, count});
-#endif // REACT_NATIVE_MINOR_VERSION >= 78
+      LayoutAnimation{
+          .finalView = finalView,
+          .currentView = currentView,
+          .parentTag = mutation.parentTag,
+          .opacity = {},
+          .isViewAlreadyMounted = false,
+          .count = count});
 }
 
-void LayoutAnimationsProxy::startEnteringAnimation(
-    const int tag,
-    ShadowViewMutation &mutation) const {
+void LayoutAnimationsProxy_Legacy::startEnteringAnimation(const int tag, ShadowViewMutation &mutation) const {
 #ifdef LAYOUT_ANIMATIONS_LOGS
   LOG(INFO) << "start entering animation for tag " << tag << std::endl;
 #endif
-  auto finalView = std::make_shared<ShadowView>(mutation.newChildShadowView);
-  auto current = std::make_shared<ShadowView>(mutation.newChildShadowView);
-#if REACT_NATIVE_MINOR_VERSION < 78
-  auto parent = std::make_shared<ShadowView>(mutation.parentShadowView);
-#endif
+  auto finalView = mutation.newChildShadowView;
+  auto current = mutation.newChildShadowView;
 
-  auto &viewProps =
-      static_cast<const ViewProps &>(*mutation.newChildShadowView.props);
+  auto &viewProps = static_cast<const ViewProps &>(*mutation.newChildShadowView.props);
   auto opacity = viewProps.opacity;
 
-  uiScheduler_->scheduleOnUI([weakThis = weak_from_this(),
-                              finalView,
-                              current,
-#if REACT_NATIVE_MINOR_VERSION < 78
-                              parent,
-#endif // RE
-                              mutation,
-                              opacity,
-                              tag]() {
+  uiScheduler_->scheduleOnUI([weakThis = weak_from_this(), finalView, current, mutation, opacity, tag]() {
     auto strongThis = weakThis.lock();
     if (!strongThis) {
       return;
@@ -669,17 +647,10 @@ void LayoutAnimationsProxy::startEnteringAnimation(
       auto &mutex = strongThis->mutex;
       auto lock = std::unique_lock<std::recursive_mutex>(mutex);
       strongThis->layoutAnimations_.insert_or_assign(
-          tag, LayoutAnimation {
-            finalView, current,
-#if REACT_NATIVE_MINOR_VERSION >= 78
-                mutation.parentTag,
-#else
-              parent,
-#endif // REACT_NATIVE_MINOR_VERSION >= 78
-                opacity
-          });
-      window = strongThis->surfaceManager.getWindow(
-          mutation.newChildShadowView.surfaceId);
+          tag,
+          LayoutAnimation{
+              .finalView = finalView, .currentView = current, .parentTag = mutation.parentTag, .opacity = opacity});
+      window = strongThis->surfaceManager.getWindow(mutation.newChildShadowView.surfaceId);
     }
 
     Snapshot values(mutation.newChildShadowView, window);
@@ -698,60 +669,52 @@ void LayoutAnimationsProxy::startEnteringAnimation(
   });
 }
 
-void LayoutAnimationsProxy::startExitingAnimation(
-    const int tag,
-    ShadowViewMutation &mutation) const {
+void LayoutAnimationsProxy_Legacy::startExitingAnimation(const int tag, ShadowViewMutation &mutation) const {
 #ifdef LAYOUT_ANIMATIONS_LOGS
   LOG(INFO) << "start exiting animation for tag " << tag << std::endl;
 #endif
   auto surfaceId = mutation.oldChildShadowView.surfaceId;
 
-  uiScheduler_->scheduleOnUI(
-      [weakThis = weak_from_this(), tag, mutation, surfaceId]() {
-        auto strongThis = weakThis.lock();
-        if (!strongThis) {
-          return;
-        }
+  uiScheduler_->scheduleOnUI([weakThis = weak_from_this(), tag, mutation, surfaceId]() {
+    auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
 
-        auto oldView = mutation.oldChildShadowView;
-        Rect window{};
-        {
-          auto &mutex = strongThis->mutex;
-          auto lock = std::unique_lock<std::recursive_mutex>(mutex);
-          strongThis->createLayoutAnimation(mutation, oldView, surfaceId, tag);
-          window = strongThis->surfaceManager.getWindow(surfaceId);
-        }
+    auto oldView = mutation.oldChildShadowView;
+    Rect window{};
+    {
+      auto &mutex = strongThis->mutex;
+      auto lock = std::unique_lock<std::recursive_mutex>(mutex);
+      strongThis->createLayoutAnimation(mutation, oldView, surfaceId, tag);
+      window = strongThis->surfaceManager.getWindow(surfaceId);
+    }
+
+    Snapshot values(oldView, window);
 
-        Snapshot values(oldView, window);
-
-        auto &uiRuntime = strongThis->uiRuntime_;
-        jsi::Object yogaValues(uiRuntime);
-        yogaValues.setProperty(uiRuntime, "currentOriginX", values.x);
-        yogaValues.setProperty(uiRuntime, "currentGlobalOriginX", values.x);
-        yogaValues.setProperty(uiRuntime, "currentOriginY", values.y);
-        yogaValues.setProperty(uiRuntime, "currentGlobalOriginY", values.y);
-        yogaValues.setProperty(uiRuntime, "currentWidth", values.width);
-        yogaValues.setProperty(uiRuntime, "currentHeight", values.height);
-        yogaValues.setProperty(uiRuntime, "windowWidth", values.windowWidth);
-        yogaValues.setProperty(uiRuntime, "windowHeight", values.windowHeight);
-        strongThis->layoutAnimationsManager_->startLayoutAnimation(
-            uiRuntime, tag, LayoutAnimationType::EXITING, yogaValues);
-        strongThis->layoutAnimationsManager_->clearLayoutAnimationConfig(tag);
-      });
+    auto &uiRuntime = strongThis->uiRuntime_;
+    jsi::Object yogaValues(uiRuntime);
+    yogaValues.setProperty(uiRuntime, "currentOriginX", values.x);
+    yogaValues.setProperty(uiRuntime, "currentGlobalOriginX", values.x);
+    yogaValues.setProperty(uiRuntime, "currentOriginY", values.y);
+    yogaValues.setProperty(uiRuntime, "currentGlobalOriginY", values.y);
+    yogaValues.setProperty(uiRuntime, "currentWidth", values.width);
+    yogaValues.setProperty(uiRuntime, "currentHeight", values.height);
+    yogaValues.setProperty(uiRuntime, "windowWidth", values.windowWidth);
+    yogaValues.setProperty(uiRuntime, "windowHeight", values.windowHeight);
+    strongThis->layoutAnimationsManager_->startLayoutAnimation(
+        uiRuntime, tag, LayoutAnimationType::EXITING, yogaValues);
+    strongThis->layoutAnimationsManager_->clearLayoutAnimationConfig(tag);
+  });
 }
 
-void LayoutAnimationsProxy::startLayoutAnimation(
-    const int tag,
-    const ShadowViewMutation &mutation) const {
+void LayoutAnimationsProxy_Legacy::startLayoutAnimation(const int tag, const ShadowViewMutation &mutation) const {
 #ifdef LAYOUT_ANIMATIONS_LOGS
   LOG(INFO) << "start layout animation for tag " << tag << std::endl;
 #endif
   auto surfaceId = mutation.oldChildShadowView.surfaceId;
 
-  uiScheduler_->scheduleOnUI([weakThis = weak_from_this(),
-                              mutation,
-                              surfaceId,
-                              tag]() {
+  uiScheduler_->scheduleOnUI([weakThis = weak_from_this(), mutation, surfaceId, tag]() {
     auto strongThis = weakThis.lock();
     if (!strongThis) {
       return;
@@ -784,21 +747,18 @@ void LayoutAnimationsProxy::startLayoutAnimation(
     yogaValues.setProperty(uiRuntime, "targetWidth", targetValues.width);
     yogaValues.setProperty(uiRuntime, "targetHeight", targetValues.height);
     yogaValues.setProperty(uiRuntime, "windowWidth", targetValues.windowWidth);
-    yogaValues.setProperty(
-        uiRuntime, "windowHeight", targetValues.windowHeight);
-    strongThis->layoutAnimationsManager_->startLayoutAnimation(
-        uiRuntime, tag, LayoutAnimationType::LAYOUT, yogaValues);
+    yogaValues.setProperty(uiRuntime, "windowHeight", targetValues.windowHeight);
+    strongThis->layoutAnimationsManager_->startLayoutAnimation(uiRuntime, tag, LayoutAnimationType::LAYOUT, yogaValues);
   });
 }
 
-void LayoutAnimationsProxy::updateOngoingAnimationTarget(
-    const int tag,
-    const ShadowViewMutation &mutation) const {
-  layoutAnimations_[tag].finalView =
-      std::make_shared<ShadowView>(mutation.newChildShadowView);
+void LayoutAnimationsProxy_Legacy::updateOngoingAnimationTarget(const int tag, const ShadowViewMutation &mutation)
+    const {
+  auto copy = mutation.newChildShadowView;
+  layoutAnimations_[tag].finalView = copy;
 }
 
-void LayoutAnimationsProxy::maybeCancelAnimation(const int tag) const {
+void LayoutAnimationsProxy_Legacy::maybeCancelAnimation(const int tag) const {
   if (!layoutAnimations_.contains(tag)) {
     return;
   }
@@ -814,9 +774,7 @@ void LayoutAnimationsProxy::maybeCancelAnimation(const int tag) const {
   });
 }
 
-void LayoutAnimationsProxy::transferConfigFromNativeID(
-    const std::string nativeIdString,
-    const int tag) const {
+void LayoutAnimationsProxy_Legacy::transferConfigFromNativeID(const std::string &nativeIdString, const int tag) const {
   if (nativeIdString.empty()) {
     return;
   }
@@ -824,40 +782,41 @@ void LayoutAnimationsProxy::transferConfigFromNativeID(
     auto nativeId = stoi(nativeIdString);
     layoutAnimationsManager_->transferConfigFromNativeID(nativeId, tag);
   } catch (std::invalid_argument) {
-  } catch (std::out_of_range) {
-  }
+  } catch (std::out_of_range) {}
 }
 
 // When entering animations start, we temporarily set opacity to 0
 // so that we can immediately insert the view at the right position
 // and schedule the animation on the UI thread
-std::shared_ptr<ShadowView> LayoutAnimationsProxy::cloneViewWithoutOpacity(
+std::shared_ptr<ShadowView> LayoutAnimationsProxy_Legacy::cloneViewWithoutOpacity(
     facebook::react::ShadowViewMutation &mutation,
     const PropsParserContext &propsParserContext) const {
   auto newView = std::make_shared<ShadowView>(mutation.newChildShadowView);
   folly::dynamic opacity = folly::dynamic::object("opacity", 0);
-  auto newProps = getComponentDescriptorForShadowView(*newView).cloneProps(
-      propsParserContext, newView->props, RawProps(opacity));
+  auto newProps =
+      getComponentDescriptorForShadowView(*newView).cloneProps(propsParserContext, newView->props, RawProps(opacity));
   newView->props = newProps;
   return newView;
 }
 
-void LayoutAnimationsProxy::maybeRestoreOpacity(
-    LayoutAnimation &layoutAnimation,
-    const jsi::Object &newStyle) const {
+void LayoutAnimationsProxy_Legacy::maybeRestoreOpacity(LayoutAnimation &layoutAnimation, const jsi::Object &newStyle)
+    const {
   if (layoutAnimation.opacity && !newStyle.hasProperty(uiRuntime_, "opacity")) {
-    newStyle.setProperty(
-        uiRuntime_, "opacity", jsi::Value(*layoutAnimation.opacity));
-    layoutAnimation.opacity.reset();
+    newStyle.setProperty(uiRuntime_, "opacity", jsi::Value(*layoutAnimation.opacity));
+    if (layoutAnimation.isViewAlreadyMounted) {
+      // We want to reset opacity only when we are sure that this update will be
+      // applied to the native view. Otherwise, we want to update opacity using
+      // the `restoreOpacityInCaseOfFlakyEnteringAnimation` method.
+      layoutAnimation.opacity.reset();
+    }
   }
 }
 
-void LayoutAnimationsProxy::maybeUpdateWindowDimensions(
+void LayoutAnimationsProxy_Legacy::maybeUpdateWindowDimensions(
     facebook::react::ShadowViewMutation &mutation,
     SurfaceId surfaceId) const {
   if (mutation.type == ShadowViewMutation::Update &&
-      !std::strcmp(
-          mutation.oldChildShadowView.componentName, RootComponentName)) {
+      !std::strcmp(mutation.oldChildShadowView.componentName, RootComponentName)) {
     surfaceManager.updateWindow(
         surfaceId,
         mutation.newChildShadowView.layoutMetrics.frame.size.width,
@@ -865,6 +824,74 @@ void LayoutAnimationsProxy::maybeUpdateWindowDimensions(
   }
 }
 
-} // namespace reanimated
+void Node::applyMutationToIndices(ShadowViewMutation mutation) {
+  const auto parentTag = mutation.parentTag;
+  if (tag != parentTag) {
+    return;
+  }
+
+  int delta = mutation.type == ShadowViewMutation::Insert ? 1 : -1;
+  for (auto it = children.rbegin(); it != children.rend(); ++it) {
+    const auto& child = *it;
+    if (child->mutation.index < mutation.index) {
+      return;
+    }
+    child->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;
+    }
+  }
 
-#endif // RCT_NEW_ARCH_ENABLED
+  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);
+}
+
+inline bool Node::isMutationNode() {
+  return false;
+}
+
+inline bool MutationNode::isMutationNode() {
+  return true;
+}
+
+// UIManagerAnimationDelegate
+
+void LayoutAnimationsProxy_Legacy::uiManagerDidConfigureNextLayoutAnimation(
+    jsi::Runtime &runtime,
+    const RawValue &config,
+    const jsi::Value &successCallbackValue,
+    const jsi::Value &failureCallbackValue) const {}
+
+void LayoutAnimationsProxy_Legacy::setComponentDescriptorRegistry(
+    const SharedComponentDescriptorRegistry &componentDescriptorRegistry) {}
+
+bool LayoutAnimationsProxy_Legacy::shouldAnimateFrame() const {
+  return false;
+}
+
+void LayoutAnimationsProxy_Legacy::stopSurface(SurfaceId surfaceId) {
+  surfacesToRemove_.insert(surfaceId);
+}
+
+} // namespace reanimated