react-native-reanimated 3.18.0 → 3.18.1

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

@@ -52,7 +52,12 @@ void ReanimatedCommitHook::maybeInitializeLayoutAnimations(
 RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
     ShadowTree const &,
     RootShadowNode::Shared const &,
-    RootShadowNode::Unshared const &newRootShadowNode) noexcept {
+    RootShadowNode::Unshared const &newRootShadowNode
+#if REACT_NATIVE_MINOR_VERSION >= 80
+    ,
+    const ShadowTreeCommitOptions &commitOptions
+#endif
+    ) noexcept {
   maybeInitializeLayoutAnimations(newRootShadowNode->getSurfaceId());
 
   auto reaShadowNode =
@@ -89,8 +94,15 @@ RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
     // PropsRegistry.
     // This is very important, since if we didn't pause Reanimated commits,
     // it could lead to RN commits being delayed until the animation is finished
-    // (very bad).
+    // (very bad). We don't pause Reanimated commits for state updates coming
+    // from React Native as this would break sticky header animations.
+#if REACT_NATIVE_MINOR_VERSION >= 80
+    if (commitOptions.source == ShadowTreeCommitSource::React) {
+      propsRegistry_->pauseReanimatedCommits();
+    }
+#else
     propsRegistry_->pauseReanimatedCommits();
+#endif
   }
 
   return rootNode;

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

@@ -32,7 +32,12 @@ class ReanimatedCommitHook
   RootShadowNode::Unshared shadowTreeWillCommit(
       ShadowTree const &shadowTree,
       RootShadowNode::Shared const &oldRootShadowNode,
-      RootShadowNode::Unshared const &newRootShadowNode) noexcept override;
+      RootShadowNode::Unshared const &newRootShadowNode
+#if REACT_NATIVE_MINOR_VERSION >= 80
+      ,
+      const ShadowTreeCommitOptions &commitOptions
+#endif
+      ) noexcept override;
 
  private:
   std::shared_ptr<PropsRegistry> propsRegistry_;

package/Common/cpp/reanimated/Fabric/ReanimatedMountHook.cpp

@@ -18,7 +18,12 @@ ReanimatedMountHook::~ReanimatedMountHook() noexcept {
 
 void ReanimatedMountHook::shadowTreeDidMount(
     const RootShadowNode::Shared &rootShadowNode,
-    double) noexcept {
+#if REACT_NATIVE_MINOR_VERSION >= 81
+    HighResTimeStamp
+#else
+    double
+#endif // REACT_NATIVE_MINOR_VERSION >= 81
+    ) noexcept {
   auto reaShadowNode =
       std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(
           std::const_pointer_cast<RootShadowNode>(rootShadowNode));

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

@@ -21,7 +21,12 @@ class ReanimatedMountHook : public UIManagerMountHook {
 
   void shadowTreeDidMount(
       RootShadowNode::Shared const &rootShadowNode,
-      double mountTime) noexcept override;
+#if REACT_NATIVE_MINOR_VERSION >= 81
+      HighResTimeStamp /*unmountTime*/
+#else
+      double /*unmountTime*/
+#endif // REACT_NATIVE_MINOR_VERSION >= 81
+      ) noexcept override;
 
  private:
   const std::shared_ptr<PropsRegistry> propsRegistry_;

package/Common/cpp/reanimated/Fabric/ShadowTreeCloner.cpp

@@ -42,7 +42,7 @@ Props::Shared mergeProps(
   return newProps;
 }
 
-ShadowNode::Unshared cloneShadowTreeWithNewPropsRecursive(
+std::shared_ptr<ShadowNode> cloneShadowTreeWithNewPropsRecursive(
     const ShadowNode &shadowNode,
     const ChildrenMap &childrenMap,
     const PropsMap &propsMap) {
@@ -59,7 +59,8 @@ ShadowNode::Unshared cloneShadowTreeWithNewPropsRecursive(
 
   return shadowNode.clone(
       {mergeProps(shadowNode, propsMap, *family),
-       std::make_shared<ShadowNode::ListOfShared>(children),
+       std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>(
+           children),
        shadowNode.getState()});
 }
 

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

@@ -31,13 +31,25 @@ std::optional<MountingTransaction> LayoutAnimationsProxy::pullTransaction(
   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);
+
+  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);
@@ -70,7 +82,7 @@ std::optional<SurfaceId> LayoutAnimationsProxy::progressLayoutAnimation(
 
   PropsParserContext propsParserContext{
       layoutAnimation.finalView->surfaceId, *contextContainer_};
-#ifdef ANDROID
+#ifdef RN_SERIALIZABLE_STATE
   rawProps = std::make_shared<RawProps>(folly::dynamic::merge(
       layoutAnimation.finalView->props->rawProps, (folly::dynamic)*rawProps));
 #endif
@@ -112,11 +124,8 @@ std::optional<SurfaceId> LayoutAnimationsProxy::endLayoutAnimation(
     layoutAnimation.count--;
     return {};
   }
-
+  finishedAnimationTags_.push_back(tag);
   auto surfaceId = layoutAnimation.finalView->surfaceId;
-  auto &updateMap = surfaceManager.getUpdateMap(surfaceId);
-  layoutAnimations_.erase(tag);
-  updateMap.erase(tag);
 
   if (!shouldRemove || !nodeForTag_.contains(tag)) {
     return {};
@@ -125,6 +134,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;
@@ -135,7 +145,7 @@ std::optional<SurfaceId> LayoutAnimationsProxy::endLayoutAnimation(
  traversals and index maintenance
  */
 void LayoutAnimationsProxy::parseRemoveMutations(
-    std::unordered_map<Tag, ShadowView> &movedViews,
+    std::unordered_map<Tag, Tag> &movedViews,
     ShadowViewMutationList &mutations,
     std::vector<std::shared_ptr<MutationNode>> &roots) const {
   std::set<Tag> deletedViews;
@@ -180,8 +190,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;
 
@@ -211,7 +220,13 @@ void LayoutAnimationsProxy::parseRemoveMutations(
       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;
     }
   }
 
@@ -239,13 +254,15 @@ void LayoutAnimationsProxy::parseRemoveMutations(
 
 void LayoutAnimationsProxy::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)) {
+            node, true, shouldAnimate, false, filteredMutations)) {
       filteredMutations.push_back(node->mutation);
       node->unflattenedParent->removeChildFromUnflattenedTree(node); //???
       if (node->state != MOVED) {
@@ -253,6 +270,7 @@ void LayoutAnimationsProxy::handleRemovals(
         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
@@ -271,7 +289,7 @@ void LayoutAnimationsProxy::handleRemovals(
 
 void LayoutAnimationsProxy::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 {
@@ -320,6 +338,9 @@ void LayoutAnimationsProxy::handleUpdatesAndEnterings(
           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;
         }
 
@@ -364,7 +385,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;
       }
 
@@ -449,6 +475,7 @@ 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
@@ -483,7 +510,8 @@ bool LayoutAnimationsProxy::startAnimationsRecursively(
   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
@@ -669,15 +697,16 @@ 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,
+          tag,
+          LayoutAnimation{
+              finalView,
+              current,
 #if REACT_NATIVE_MINOR_VERSION >= 78
-                mutation.parentTag,
+              mutation.parentTag,
 #else
               parent,
 #endif // REACT_NATIVE_MINOR_VERSION >= 78
-                opacity
-          });
+              opacity});
       window = strongThis->surfaceManager.getWindow(
           mutation.newChildShadowView.surfaceId);
     }
@@ -865,6 +894,25 @@ void LayoutAnimationsProxy::maybeUpdateWindowDimensions(
   }
 }
 
+// UIManagerAnimationDelegate
+
+void LayoutAnimationsProxy::uiManagerDidConfigureNextLayoutAnimation(
+    jsi::Runtime &runtime,
+    const RawValue &config,
+    const jsi::Value &successCallbackValue,
+    const jsi::Value &failureCallbackValue) const {}
+
+void LayoutAnimationsProxy::setComponentDescriptorRegistry(
+    const SharedComponentDescriptorRegistry &componentDescriptorRegistry) {}
+
+bool LayoutAnimationsProxy::shouldAnimateFrame() const {
+  return false;
+}
+
+void LayoutAnimationsProxy::stopSurface(SurfaceId surfaceId) {
+  surfacesToRemove_.insert(surfaceId);
+}
+
 } // namespace reanimated
 
 #endif // RCT_NEW_ARCH_ENABLED

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

@@ -10,6 +10,7 @@
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
 #include <react/renderer/mounting/ShadowView.h>
+#include <react/renderer/uimanager/UIManagerAnimationDelegate.h>
 
 #include <memory>
 #include <string>
@@ -35,15 +36,22 @@ struct LayoutAnimation {
   LayoutAnimation &operator=(const LayoutAnimation &other) = default;
 };
 
+struct SurfaceContext {
+  mutable std::unordered_set<std::shared_ptr<MutationNode>> deadNodes;
+};
+
 struct LayoutAnimationsProxy
     : public MountingOverrideDelegate,
+      public UIManagerAnimationDelegate,
       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;
   mutable SurfaceManager surfaceManager;
-  mutable std::unordered_set<std::shared_ptr<MutationNode>> deadNodes;
+  mutable std::unordered_map<SurfaceId, SurfaceContext> surfaceContext_;
   mutable std::unordered_map<Tag, int> leastRemoved;
+  mutable std::unordered_set<SurfaceId> surfacesToRemove_;
+  mutable std::vector<Tag> finishedAnimationTags_;
   std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager_;
   ContextContainer::Shared contextContainer_;
   SharedComponentDescriptorRegistry componentDescriptorRegistry_;
@@ -76,16 +84,18 @@ struct LayoutAnimationsProxy
   void maybeCancelAnimation(const int tag) const;
 
   void parseRemoveMutations(
-      std::unordered_map<Tag, ShadowView> &movedViews,
+      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) const;
+      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, ShadowView> &movedViews,
+      const std::unordered_map<Tag, Tag> &movedViews,
       ShadowViewMutationList &mutations,
       const PropsParserContext &propsParserContext,
       SurfaceId surfaceId) const;
@@ -140,6 +150,21 @@ struct LayoutAnimationsProxy
       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/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsUtils.h

@@ -136,11 +136,10 @@ static inline void updateLayoutMetrics(
 }
 
 static inline bool isRNSScreen(std::shared_ptr<MutationNode> node) {
-  return !std::strcmp(
-             node->mutation.oldChildShadowView.componentName,
-             "RNSScreenStack") ||
-      !std::strcmp(
-          node->mutation.oldChildShadowView.componentName, "RNSScreen");
+  const auto &componentName = node->mutation.oldChildShadowView.componentName;
+  return !std::strcmp(componentName, "RNSScreenStack") ||
+      !std::strcmp(componentName, "RNSScreen") ||
+      !std::strcmp(componentName, "RNSModalScreen");
 }
 
 static inline bool hasLayoutChanged(const ShadowViewMutation &mutation) {

package/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.cpp

@@ -23,7 +23,6 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 #include <react/renderer/scheduler/Scheduler.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
-#include <react/renderer/uimanager/primitives.h>
 #endif // RCT_NEW_ARCH_ENABLED
 
 #include <functional>
@@ -37,6 +36,15 @@
 
 namespace reanimated {
 
+#if REACT_NATIVE_MINOR_VERSION >= 81
+static inline std::shared_ptr<const ShadowNode> shadowNodeFromValue(
+    jsi::Runtime &rt,
+    const jsi::Value &shadowNodeWrapper) {
+  return Bridging<std::shared_ptr<const ShadowNode>>::fromJs(
+      rt, shadowNodeWrapper);
+}
+#endif
+
 ReanimatedModuleProxy::ReanimatedModuleProxy(
     const std::shared_ptr<WorkletsModuleProxy> &workletsModuleProxy,
     jsi::Runtime &rnRuntime,
@@ -49,13 +57,14 @@ ReanimatedModuleProxy::ReanimatedModuleProxy(
       isReducedMotion_(isReducedMotion),
       workletsModuleProxy_(workletsModuleProxy),
       valueUnpackerCode_(workletsModuleProxy->getValueUnpackerCode()),
-      uiWorkletRuntime_(std::make_shared<WorkletRuntime>(
-          rnRuntime,
-          workletsModuleProxy->getJSQueue(),
-          workletsModuleProxy->getJSScheduler(),
-          "Reanimated UI runtime",
-          true /* supportsLocking */,
-          valueUnpackerCode_)),
+      uiWorkletRuntime_(
+          std::make_shared<WorkletRuntime>(
+              rnRuntime,
+              workletsModuleProxy->getJSQueue(),
+              workletsModuleProxy->getJSScheduler(),
+              "Reanimated UI runtime",
+              true /* supportsLocking */,
+              valueUnpackerCode_)),
       eventHandlerRegistry_(std::make_unique<EventHandlerRegistry>()),
       requestRender_(platformDepMethodsHolder.requestRender),
       animatedSensorModule_(platformDepMethodsHolder),
@@ -161,14 +170,20 @@ void ReanimatedModuleProxy::init(
         if (!surfaceId) {
           return;
         }
-        strongThis->uiManager_->getShadowTreeRegistry().visit(
-            *surfaceId, [](const ShadowTree &shadowTree) {
-              shadowTree.notifyDelegatesOfUpdates();
-            });
+        strongThis->layoutAnimationFlushRequests_.insert(*surfaceId);
       };
 
+  auto requestLayoutAnimationRender = [weakThis = weak_from_this()](double) {
+    auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
+    strongThis->layoutAnimationRenderRequested_ = false;
+  };
+
   EndLayoutAnimationFunction endLayoutAnimation =
-      [weakThis = weak_from_this()](int tag, bool shouldRemove) {
+      [weakThis = weak_from_this(), requestLayoutAnimationRender](
+          int tag, bool shouldRemove) {
         auto strongThis = weakThis.lock();
         if (!strongThis) {
           return;
@@ -176,14 +191,19 @@ void ReanimatedModuleProxy::init(
 
         auto surfaceId = strongThis->layoutAnimationsProxy_->endLayoutAnimation(
             tag, shouldRemove);
+
+        if (!strongThis->layoutAnimationRenderRequested_) {
+          strongThis->layoutAnimationRenderRequested_ = true;
+          // if an animation has duration 0, performOperations would not get
+          // called for it so we call requestRender to have it called in the
+          // next frame
+          strongThis->requestRender_(requestLayoutAnimationRender);
+        }
+
         if (!surfaceId) {
           return;
         }
-
-        strongThis->uiManager_->getShadowTreeRegistry().visit(
-            *surfaceId, [](const ShadowTree &shadowTree) {
-              shadowTree.notifyDelegatesOfUpdates();
-            });
+        strongThis->layoutAnimationFlushRequests_.insert(*surfaceId);
       };
 
   auto obtainProp = [weakThis = weak_from_this()](
@@ -355,7 +375,7 @@ static inline std::string intColorToHex(const int val) {
 std::string ReanimatedModuleProxy::obtainPropFromShadowNode(
     jsi::Runtime &rt,
     const std::string &propName,
-    const ShadowNode::Shared &shadowNode) {
+    const std::shared_ptr<const ShadowNode> &shadowNode) {
   auto newestCloneOfShadowNode =
       uiManager_->getNewestCloneOfShadowNode(*shadowNode);
 
@@ -390,9 +410,10 @@ std::string ReanimatedModuleProxy::obtainPropFromShadowNode(
     }
   }
 
-  throw std::runtime_error(std::string(
-      "Getting property `" + propName +
-      "` with function `getViewProp` is not supported"));
+  throw std::runtime_error(
+      std::string(
+          "Getting property `" + propName +
+          "` with function `getViewProp` is not supported"));
 }
 
 jsi::Value ReanimatedModuleProxy::getViewProp(
@@ -700,13 +721,23 @@ void ReanimatedModuleProxy::updateProps(
 }
 
 void ReanimatedModuleProxy::performOperations() {
+  ReanimatedSystraceSection s("performOperations");
+
+  if (!layoutAnimationFlushRequests_.empty()) {
+    auto flushRequestsCopy = std::move(layoutAnimationFlushRequests_);
+    for (const auto surfaceId : flushRequestsCopy) {
+      uiManager_->getShadowTreeRegistry().visit(
+          surfaceId, [](const ShadowTree &shadowTree) {
+            shadowTree.notifyDelegatesOfUpdates();
+          });
+    }
+  }
+
   if (operationsInBatch_.empty() && tagsToRemove_.empty()) {
     // nothing to do
     return;
   }
 
-  ReanimatedSystraceSection s("performOperations");
-
   auto copiedOperationsQueue = std::move(operationsInBatch_);
   operationsInBatch_.clear();
 
@@ -809,7 +840,7 @@ void ReanimatedModuleProxy::dispatchCommand(
     const jsi::Value &shadowNodeValue,
     const jsi::Value &commandNameValue,
     const jsi::Value &argsValue) {
-  ShadowNode::Shared shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
+  const auto shadowNode = shadowNodeFromValue(rt, shadowNodeValue);
   std::string commandName = stringFromValue(rt, commandNameValue);
   folly::dynamic args = commandArgsFromValue(rt, argsValue);
   const auto &scheduler = static_cast<Scheduler *>(uiManager_->getDelegate());
@@ -911,6 +942,7 @@ void ReanimatedModuleProxy::initializeLayoutAnimationsProxy() {
         scheduler->getContextContainer(),
         uiWorkletRuntime_->getJSIRuntime(),
         workletsModuleProxy_->getUIScheduler());
+        uiManager_->setAnimationDelegate(layoutAnimationsProxy_.get());
   }
 }
 

package/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.h

@@ -23,6 +23,7 @@
 #endif // RCT_NEW_ARCH_ENABLED
 
 #include <memory>
+#include <set>
 #include <string>
 #include <unordered_set>
 #include <utility>
@@ -150,7 +151,7 @@ class ReanimatedModuleProxy
   std::string obtainPropFromShadowNode(
       jsi::Runtime &rt,
       const std::string &propName,
-      const ShadowNode::Shared &shadowNode);
+      const std::shared_ptr<const ShadowNode> &shadowNode);
 
 #ifdef IS_REANIMATED_EXAMPLE_APP
   std::function<std::string()> createRegistriesLeakCheck();
@@ -233,6 +234,8 @@ class ReanimatedModuleProxy
   std::shared_ptr<PropsRegistry> propsRegistry_;
   std::shared_ptr<ReanimatedCommitHook> commitHook_;
   std::shared_ptr<ReanimatedMountHook> mountHook_;
+  std::set<SurfaceId> layoutAnimationFlushRequests_;
+  bool layoutAnimationRenderRequested_;
 
   std::vector<Tag> tagsToRemove_; // from `propsRegistry_`
 #else

package/README.md

@@ -6,21 +6,9 @@
 
 React Native Reanimated provides a more comprehensive,
 low-level abstraction for the Animated library API on which to build,
-allowing for much greater flexibility, especially when it comes to 
+allowing for much greater flexibility, especially when it comes to
 gesture-based interactions.
 
-### Nightly CI state
-
-[![NPM Reanimated publish nightly](https://github.com/software-mansion/react-native-reanimated/actions/workflows/npm-reanimated-publish-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/npm-reanimated-publish-nightly.yml)
-[![Reanimated compatibility check](https://github.com/software-mansion/react-native-reanimated/actions/workflows/reanimated-compatibility-check-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/reanimated-compatibility-check-nightly.yml)
-[![Static framework Reanimated build check](https://github.com/software-mansion/react-native-reanimated/actions/workflows/static-framework-reanimated-build-check-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/static-framework-reanimated-build-check-nightly.yml)
-[![React Native nightly Reanimated build check](https://github.com/software-mansion/react-native-reanimated/actions/workflows/react-native-nightly-reanimated-build-check-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/react-native-nightly-reanimated-build-check-nightly.yml)
-[![Expo DevClient build check](https://github.com/software-mansion/react-native-reanimated/actions/workflows/expo-devclient-build-check-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/expo-devclient-build-check-nightly.yml)
-[![Reanimated TypeScript compatibility test](https://github.com/software-mansion/react-native-reanimated/actions/workflows/reanimated-typescript-compatibility-test-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/reanimated-typescript-compatibility-test-nightly.yml)
-[![V8 Reanimated build check](https://github.com/software-mansion/react-native-reanimated/actions/workflows/V8-reanimated-build-check-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/V8-reanimated-build-check-nightly.yml)
-[![Windows hosted app Reanimated build check](https://github.com/software-mansion/react-native-reanimated/actions/workflows/windows-hosted-app-reanimated-build-check-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/windows-hosted-app-reanimated-build-check-nightly.yml)
-[![URL validation](https://github.com/software-mansion/react-native-reanimated/actions/workflows/url-validation-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/url-validation-nightly.yml)
-
 ## Installation
 
 Check out the [installation](https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/getting-started/#installation) section of our docs for the detailed installation instructions.

package/RNReanimated.podspec

@@ -81,7 +81,7 @@ Pod::Spec.new do |s|
       '"$(PODS_ROOT)/Headers/Private/Yoga"',
     ].join(' '),
     "FRAMEWORK_SEARCH_PATHS" => '"${PODS_CONFIGURATION_BUILD_DIR}/React-hermes"',
-    "CLANG_CXX_LANGUAGE_STANDARD" => "c++17",
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
     "GCC_PREPROCESSOR_DEFINITIONS[config=*Debug*]" => hermes_debug_hidden_flags,
     "GCC_PREPROCESSOR_DEFINITIONS[config=*Release*]" => '$(inherited)',
   }