react-native-reanimated 3.17.0-rc.0 → 3.17.0

package/Common/cpp/reanimated/Fabric/ReanimatedCommitHook.cpp

@@ -27,23 +27,33 @@ ReanimatedCommitHook::~ReanimatedCommitHook() noexcept {
   uiManager_->unregisterCommitHook(*this);
 }
 
+void ReanimatedCommitHook::maybeInitializeLayoutAnimations(
+    SurfaceId surfaceId) {
+  auto lock = std::unique_lock<std::mutex>(mutex_);
+  if (surfaceId > currentMaxSurfaceId_) {
+    // when a new surfaceId is observed we call setMountingOverrideDelegate
+    // for all yet unseen surfaces
+    uiManager_->getShadowTreeRegistry().enumerate(
+        [strongThis = shared_from_this()](
+            const ShadowTree &shadowTree, bool &stop) {
+          // Executed synchronously.
+          if (shadowTree.getSurfaceId() <= strongThis->currentMaxSurfaceId_) {
+            // the set function actually adds our delegate to a list, so we
+            // shouldn't invoke it twice for the same surface
+            return;
+          }
+          shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(
+              strongThis->layoutAnimationsProxy_);
+        });
+    currentMaxSurfaceId_ = surfaceId;
+  }
+}
+
 RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
     ShadowTree const &,
     RootShadowNode::Shared const &,
     RootShadowNode::Unshared const &newRootShadowNode) noexcept {
-  auto surfaceId = newRootShadowNode->getSurfaceId();
-
-  {
-    auto lock = std::unique_lock<std::mutex>(mutex_);
-    if (surfaceId > currentMaxSurfaceId_) {
-      uiManager_->getShadowTreeRegistry().enumerate(
-          [this](const ShadowTree &shadowTree, bool &stop) {
-            shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(
-                layoutAnimationsProxy_);
-          });
-      currentMaxSurfaceId_ = surfaceId;
-    }
-  }
+  maybeInitializeLayoutAnimations(newRootShadowNode->getSurfaceId());
 
   auto reaShadowNode =
       std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(

package/Common/cpp/reanimated/Fabric/ReanimatedCommitHook.h

@@ -12,7 +12,9 @@ using namespace facebook::react;
 
 namespace reanimated {
 
-class ReanimatedCommitHook : public UIManagerCommitHook {
+class ReanimatedCommitHook
+    : public UIManagerCommitHook,
+      public std::enable_shared_from_this<ReanimatedCommitHook> {
  public:
   ReanimatedCommitHook(
       const std::shared_ptr<PropsRegistry> &propsRegistry,
@@ -25,6 +27,8 @@ class ReanimatedCommitHook : public UIManagerCommitHook {
 
   void commitHookWasUnregistered(UIManager const &) noexcept override {}
 
+  void maybeInitializeLayoutAnimations(SurfaceId surfaceId);
+
   RootShadowNode::Unshared shadowTreeWillCommit(
       ShadowTree const &shadowTree,
       RootShadowNode::Shared const &oldRootShadowNode,

package/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsManager.cpp

@@ -116,6 +116,9 @@ void LayoutAnimationsManager::startLayoutAnimation(
   std::shared_ptr<Shareable> config, viewShareable;
   {
     auto lock = std::unique_lock<std::recursive_mutex>(animationsMutex_);
+    if (!collection::contains(getConfigsForType(type), tag)) {
+      return;
+    }
     config = getConfigsForType(type)[tag];
   }
   // TODO: cache the following!!

package/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy.cpp

@@ -1,7 +1,7 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 
 #include <reanimated/LayoutAnimations/LayoutAnimationsProxy.h>
-#include <reanimated/NativeModules/NativeReanimatedModule.h>
+#include <reanimated/NativeModules/ReanimatedModuleProxy.h>
 
 #include <react/renderer/animations/utils.h>
 #include <react/renderer/mounting/ShadowViewMutation.h>
@@ -153,7 +153,11 @@ 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;
@@ -287,9 +291,16 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
       }
       case ShadowViewMutation::Type::Insert: {
         updateIndexForMutation(mutation);
-        if (nodeForTag_.contains(mutation.parentShadowView.tag)) {
-          nodeForTag_[mutation.parentShadowView.tag]->applyMutationToIndices(
-              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);
         }
 
         if (movedViews.contains(tag)) {
@@ -297,7 +308,7 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
           if (layoutAnimationIt == layoutAnimations_.end()) {
             if (oldShadowViewsForReparentings.contains(tag)) {
               filteredMutations.push_back(ShadowViewMutation::InsertMutation(
-                  mutation.parentShadowView,
+                  mutationParent,
                   oldShadowViewsForReparentings[tag],
                   mutation.index));
             } else {
@@ -308,7 +319,7 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
 
           auto oldView = *layoutAnimationIt->second.currentView;
           filteredMutations.push_back(ShadowViewMutation::InsertMutation(
-              mutation.parentShadowView, oldView, mutation.index));
+              mutationParent, oldView, mutation.index));
           continue;
         }
 
@@ -328,7 +339,7 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
             cloneViewWithoutOpacity(mutation, propsParserContext);
 
         filteredMutations.push_back(ShadowViewMutation::UpdateMutation(
-            mutation.newChildShadowView, *newView, mutation.parentShadowView));
+            mutation.newChildShadowView, *newView, mutationParent));
         break;
       }
 
@@ -386,7 +397,14 @@ void LayoutAnimationsProxy::addOngoingAnimations(
     updateLayoutMetrics(newView->layoutMetrics, updateValues.frame);
 
     mutations.push_back(ShadowViewMutation::UpdateMutation(
-        *layoutAnimation.currentView, *newView, *layoutAnimation.parentView));
+        *layoutAnimation.currentView,
+        *newView,
+#if REACT_NATIVE_MINOR_VERSION >= 78
+        layoutAnimation.parentTag
+#else
+        *layoutAnimation.parentView
+#endif // REACT_NATIVE_MINOR_VERSION >= 78
+        ));
     layoutAnimation.currentView = newView;
   }
   updateMap.clear();
@@ -426,9 +444,8 @@ void LayoutAnimationsProxy::maybeDropAncestors(
   }
 
   auto node = std::static_pointer_cast<MutationNode>(parent);
-  node->animatedChildren.erase(child->tag);
 
-  if (node->animatedChildren.empty() && node->state != ANIMATING) {
+  if (node->children.size() == 0 && node->state != ANIMATING) {
     nodeForTag_.erase(node->tag);
     cleanupMutations.push_back(node->mutation);
     maybeCancelAnimation(node->tag);
@@ -482,7 +499,6 @@ bool LayoutAnimationsProxy::startAnimationsRecursively(
 #endif
     if (subNode->state != UNDEFINED && subNode->state != MOVED) {
       if (shouldAnimate && subNode->state != DEAD) {
-        node->animatedChildren.insert(subNode->tag);
         hasAnimatedChildren = true;
       } else {
         endAnimationsRecursively(subNode, mutations);
@@ -498,7 +514,6 @@ bool LayoutAnimationsProxy::startAnimationsRecursively(
       LOG(INFO) << "child " << subNode->tag
                 << " start animations returned true " << std::endl;
 #endif
-      node->animatedChildren.insert(subNode->tag);
       hasAnimatedChildren = true;
     } else if (subNode->state == MOVED) {
       mutations.push_back(subNode->mutation);
@@ -544,11 +559,7 @@ bool LayoutAnimationsProxy::startAnimationsRecursively(
     layoutAnimationsManager_->clearLayoutAnimationConfig(node->tag);
   }
 
-  if (!wantAnimateExit) {
-    return false;
-  }
-
-  return true;
+  return wantAnimateExit;
 }
 
 void LayoutAnimationsProxy::updateIndexForMutation(
@@ -556,12 +567,18 @@ void LayoutAnimationsProxy::updateIndexForMutation(
   if (mutation.index == -1) {
     return;
   }
-  if (!nodeForTag_.contains(mutation.parentShadowView.tag)) {
+
+#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;
   }
 
-  auto parent = nodeForTag_[mutation.parentShadowView.tag];
-
+  auto parent = nodeForTag_[parentTag];
   int size = 0, prevIndex = -1, offset = 0;
 
   for (auto &subNode : parent->children) {
@@ -576,9 +593,8 @@ void LayoutAnimationsProxy::updateIndexForMutation(
   int tag = mutation.type == ShadowViewMutation::Insert
       ? mutation.newChildShadowView.tag
       : mutation.oldChildShadowView.tag;
-  LOG(INFO) << "update index for " << tag << " in "
-            << mutation.parentShadowView.tag << ": " << mutation.index << " -> "
-            << mutation.index + offset << std::endl;
+  LOG(INFO) << "update index for " << tag << " in " << parentTag << ": "
+            << mutation.index << " -> " << mutation.index + offset << std::endl;
 #endif
   mutation.index += offset;
 }
@@ -606,9 +622,16 @@ void LayoutAnimationsProxy::createLayoutAnimation(
           ? mutation.oldChildShadowView
           : mutation.newChildShadowView);
   auto currentView = std::make_shared<ShadowView>(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
 }
 
 void LayoutAnimationsProxy::startEnteringAnimation(
@@ -619,36 +642,60 @@ void LayoutAnimationsProxy::startEnteringAnimation(
 #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 &viewProps =
       static_cast<const ViewProps &>(*mutation.newChildShadowView.props);
   auto opacity = viewProps.opacity;
 
-  uiScheduler_->scheduleOnUI(
-      [finalView, current, parent, mutation, opacity, this, tag]() {
-        Rect window{};
-        {
-          auto lock = std::unique_lock<std::recursive_mutex>(mutex);
-          layoutAnimations_.insert_or_assign(
-              tag, LayoutAnimation{finalView, current, parent, opacity});
-          window =
-              surfaceManager.getWindow(mutation.newChildShadowView.surfaceId);
-        }
+  uiScheduler_->scheduleOnUI([weakThis = weak_from_this(),
+                              finalView,
+                              current,
+#if REACT_NATIVE_MINOR_VERSION < 78
+                              parent,
+#endif // RE
+                              mutation,
+                              opacity,
+                              tag]() {
+    auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
 
-        Snapshot values(mutation.newChildShadowView, window);
-        jsi::Object yogaValues(uiRuntime_);
-        yogaValues.setProperty(uiRuntime_, "targetOriginX", values.x);
-        yogaValues.setProperty(uiRuntime_, "targetGlobalOriginX", values.x);
-        yogaValues.setProperty(uiRuntime_, "targetOriginY", values.y);
-        yogaValues.setProperty(uiRuntime_, "targetGlobalOriginY", values.y);
-        yogaValues.setProperty(uiRuntime_, "targetWidth", values.width);
-        yogaValues.setProperty(uiRuntime_, "targetHeight", values.height);
-        yogaValues.setProperty(uiRuntime_, "windowWidth", values.windowWidth);
-        yogaValues.setProperty(uiRuntime_, "windowHeight", values.windowHeight);
-        layoutAnimationsManager_->startLayoutAnimation(
-            uiRuntime_, tag, LayoutAnimationType::ENTERING, yogaValues);
-      });
+    Rect window{};
+    {
+      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);
+    }
+
+    Snapshot values(mutation.newChildShadowView, window);
+    auto &uiRuntime = strongThis->uiRuntime_;
+    jsi::Object yogaValues(uiRuntime);
+    yogaValues.setProperty(uiRuntime, "targetOriginX", values.x);
+    yogaValues.setProperty(uiRuntime, "targetGlobalOriginX", values.x);
+    yogaValues.setProperty(uiRuntime, "targetOriginY", values.y);
+    yogaValues.setProperty(uiRuntime, "targetGlobalOriginY", values.y);
+    yogaValues.setProperty(uiRuntime, "targetWidth", values.width);
+    yogaValues.setProperty(uiRuntime, "targetHeight", values.height);
+    yogaValues.setProperty(uiRuntime, "windowWidth", values.windowWidth);
+    yogaValues.setProperty(uiRuntime, "windowHeight", values.windowHeight);
+    strongThis->layoutAnimationsManager_->startLayoutAnimation(
+        uiRuntime, tag, LayoutAnimationType::ENTERING, yogaValues);
+  });
 }
 
 void LayoutAnimationsProxy::startExitingAnimation(
@@ -659,30 +706,38 @@ void LayoutAnimationsProxy::startExitingAnimation(
 #endif
   auto surfaceId = mutation.oldChildShadowView.surfaceId;
 
-  uiScheduler_->scheduleOnUI([this, tag, mutation, surfaceId]() {
-    auto oldView = mutation.oldChildShadowView;
-    Rect window{};
-    {
-      auto lock = std::unique_lock<std::recursive_mutex>(mutex);
-      createLayoutAnimation(mutation, oldView, surfaceId, tag);
-      window = surfaceManager.getWindow(surfaceId);
-    }
+  uiScheduler_->scheduleOnUI(
+      [weakThis = weak_from_this(), tag, mutation, surfaceId]() {
+        auto strongThis = weakThis.lock();
+        if (!strongThis) {
+          return;
+        }
 
-    Snapshot values(oldView, window);
-
-    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);
-    layoutAnimationsManager_->startLayoutAnimation(
-        uiRuntime_, tag, LayoutAnimationType::EXITING, yogaValues);
-    layoutAnimationsManager_->clearLayoutAnimationConfig(tag);
-  });
+        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);
+
+        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(
@@ -693,36 +748,46 @@ void LayoutAnimationsProxy::startLayoutAnimation(
 #endif
   auto surfaceId = mutation.oldChildShadowView.surfaceId;
 
-  uiScheduler_->scheduleOnUI([this, mutation, surfaceId, tag]() {
+  uiScheduler_->scheduleOnUI([weakThis = weak_from_this(),
+                              mutation,
+                              surfaceId,
+                              tag]() {
+    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);
-      createLayoutAnimation(mutation, oldView, surfaceId, tag);
-      window = surfaceManager.getWindow(surfaceId);
+      strongThis->createLayoutAnimation(mutation, oldView, surfaceId, tag);
+      window = strongThis->surfaceManager.getWindow(surfaceId);
     }
 
     Snapshot currentValues(oldView, window);
     Snapshot targetValues(mutation.newChildShadowView, window);
 
-    jsi::Object yogaValues(uiRuntime_);
-    yogaValues.setProperty(uiRuntime_, "currentOriginX", currentValues.x);
-    yogaValues.setProperty(uiRuntime_, "currentGlobalOriginX", currentValues.x);
-    yogaValues.setProperty(uiRuntime_, "currentOriginY", currentValues.y);
-    yogaValues.setProperty(uiRuntime_, "currentGlobalOriginY", currentValues.y);
-    yogaValues.setProperty(uiRuntime_, "currentWidth", currentValues.width);
-    yogaValues.setProperty(uiRuntime_, "currentHeight", currentValues.height);
-    yogaValues.setProperty(uiRuntime_, "targetOriginX", targetValues.x);
-    yogaValues.setProperty(uiRuntime_, "targetGlobalOriginX", targetValues.x);
-    yogaValues.setProperty(uiRuntime_, "targetOriginY", targetValues.y);
-    yogaValues.setProperty(uiRuntime_, "targetGlobalOriginY", targetValues.y);
-    yogaValues.setProperty(uiRuntime_, "targetWidth", targetValues.width);
-    yogaValues.setProperty(uiRuntime_, "targetHeight", targetValues.height);
-    yogaValues.setProperty(uiRuntime_, "windowWidth", targetValues.windowWidth);
+    auto &uiRuntime = strongThis->uiRuntime_;
+    jsi::Object yogaValues(uiRuntime);
+    yogaValues.setProperty(uiRuntime, "currentOriginX", currentValues.x);
+    yogaValues.setProperty(uiRuntime, "currentGlobalOriginX", currentValues.x);
+    yogaValues.setProperty(uiRuntime, "currentOriginY", currentValues.y);
+    yogaValues.setProperty(uiRuntime, "currentGlobalOriginY", currentValues.y);
+    yogaValues.setProperty(uiRuntime, "currentWidth", currentValues.width);
+    yogaValues.setProperty(uiRuntime, "currentHeight", currentValues.height);
+    yogaValues.setProperty(uiRuntime, "targetOriginX", targetValues.x);
+    yogaValues.setProperty(uiRuntime, "targetGlobalOriginX", targetValues.x);
+    yogaValues.setProperty(uiRuntime, "targetOriginY", targetValues.y);
+    yogaValues.setProperty(uiRuntime, "targetGlobalOriginY", targetValues.y);
+    yogaValues.setProperty(uiRuntime, "targetWidth", targetValues.width);
+    yogaValues.setProperty(uiRuntime, "targetHeight", targetValues.height);
+    yogaValues.setProperty(uiRuntime, "windowWidth", targetValues.windowWidth);
     yogaValues.setProperty(
-        uiRuntime_, "windowHeight", targetValues.windowHeight);
-    layoutAnimationsManager_->startLayoutAnimation(
-        uiRuntime_, tag, LayoutAnimationType::LAYOUT, yogaValues);
+        uiRuntime, "windowHeight", targetValues.windowHeight);
+    strongThis->layoutAnimationsManager_->startLayoutAnimation(
+        uiRuntime, tag, LayoutAnimationType::LAYOUT, yogaValues);
   });
 }
 
@@ -738,8 +803,14 @@ void LayoutAnimationsProxy::maybeCancelAnimation(const int tag) const {
     return;
   }
   layoutAnimations_.erase(tag);
-  uiScheduler_->scheduleOnUI([this, tag]() {
-    layoutAnimationsManager_->cancelLayoutAnimation(uiRuntime_, tag);
+  uiScheduler_->scheduleOnUI([weakThis = weak_from_this(), tag]() {
+    auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
+
+    auto &uiRuntime = strongThis->uiRuntime_;
+    strongThis->layoutAnimationsManager_->cancelLayoutAnimation(uiRuntime, tag);
   });
 }
 

package/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy.h

@@ -19,18 +19,25 @@
 
 namespace reanimated {
 
-class NativeReanimatedModule;
+class ReanimatedModuleProxy;
 
 using namespace facebook;
 
 struct LayoutAnimation {
+#if REACT_NATIVE_MINOR_VERSION >= 78
+  std::shared_ptr<ShadowView> finalView, currentView;
+  Tag parentTag;
+#else
   std::shared_ptr<ShadowView> finalView, currentView, parentView;
+#endif // REACT_NATIVE_MINOR_VERSION >= 78
   std::optional<double> opacity;
   int count = 1;
   LayoutAnimation &operator=(const LayoutAnimation &other) = default;
 };
 
-struct LayoutAnimationsProxy : public MountingOverrideDelegate {
+struct LayoutAnimationsProxy
+    : public MountingOverrideDelegate,
+      public std::enable_shared_from_this<LayoutAnimationsProxy> {
   mutable std::unordered_map<Tag, std::shared_ptr<Node>> nodeForTag_;
   mutable std::unordered_map<Tag, LayoutAnimation> layoutAnimations_;
   mutable std::recursive_mutex mutex;

package/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsUtils.cpp

@@ -31,7 +31,13 @@ Rect SurfaceManager::getWindow(SurfaceId surfaceId) {
 }
 
 void Node::applyMutationToIndices(ShadowViewMutation mutation) {
-  if (tag != mutation.parentShadowView.tag) {
+#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;
   }
 

package/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsUtils.h

@@ -96,7 +96,6 @@ struct Node {
  */
 struct MutationNode : public Node {
   ShadowViewMutation mutation;
-  std::unordered_set<Tag> animatedChildren;
   ExitingState state = UNDEFINED;
   explicit MutationNode(ShadowViewMutation &mutation)
       : Node(mutation.oldChildShadowView.tag), mutation(mutation) {}