react-native-reanimated 3.8.0 → 3.9.0-layout-animation-experimental

package/Common/cpp/LayoutAnimations/LayoutAnimationsUtils.h

@@ -0,0 +1,140 @@
+#pragma once
+
+struct Window{
+  double width, height;
+};
+
+struct Frame{
+  std::optional<double> x, y, width, height;
+  Frame(jsi::Runtime& runtime, const jsi::Object &newStyle){
+    if (newStyle.hasProperty(runtime, "originX")){
+      x = newStyle.getProperty(runtime, "originX").asNumber();
+    }
+    if (newStyle.hasProperty(runtime, "originY")){
+      y = newStyle.getProperty(runtime, "originY").asNumber();
+    }
+    if (newStyle.hasProperty(runtime, "width")){
+      width = newStyle.getProperty(runtime, "width").asNumber();
+    }
+    if (newStyle.hasProperty(runtime, "height")){
+      height = newStyle.getProperty(runtime, "height").asNumber();
+    }
+  }
+};
+
+struct UpdateValues{
+  Props::Shared newProps;
+  Frame frame;
+};
+
+struct Snapshot{
+  double x, y, width, height, windowWidth, windowHeight;
+  Snapshot(ShadowView& shadowView, Window window){
+    auto& frame = shadowView.layoutMetrics.frame;
+    x = frame.origin.x;
+    y = frame.origin.y;
+    width = frame.size.width;
+    height = frame.size.height;
+    windowWidth = window.width;
+    windowHeight = window.height;
+  }
+};
+
+struct MutationNode;
+
+struct Node {
+  std::vector<std::shared_ptr<MutationNode>> children;
+  std::shared_ptr<Node> parent;
+  Tag tag;
+  void removeChild(std::shared_ptr<MutationNode> child);
+  void addChild(std::shared_ptr<MutationNode> child);
+  Node(Tag tag): tag(tag){}
+  Node(Node&& node):children(std::move(node.children)), tag(node.tag){}
+};
+
+struct MutationNode: public Node{
+  ShadowViewMutation mutation;
+  std::unordered_set<Tag> animatedChildren;
+  bool isAnimatingExit = false;
+  bool isDone = false;
+  bool isExiting = false;
+  MutationNode(ShadowViewMutation& mutation): mutation(mutation), Node(mutation.oldChildShadowView.tag){}
+  MutationNode(ShadowViewMutation& mutation, Node&& node): mutation(mutation), Node(std::move(node)){}
+};
+
+void Node::removeChild(std::shared_ptr<MutationNode> child){
+  for (int i=0; i<children.size(); i++){
+    if (children[i]->tag == child->tag){
+      children.erase(children.begin()+i);
+      break;
+    }
+  }
+}
+void Node::addChild(std::shared_ptr<MutationNode> child){
+  bool done = false;
+  for (auto it = children.begin(); it != children.end(); it++){
+    if ((*it)->mutation.index >child->mutation.index){
+      children.insert(it, child);
+      done = true;
+      break;
+    }
+  }
+  if (!done){
+    children.push_back(child);
+  }
+}
+
+struct SurfaceManager {
+  mutable std::unordered_map<SurfaceId, std::shared_ptr<std::unordered_map<Tag, UpdateValues>>> props_;
+  mutable std::unordered_map<SurfaceId, ShadowViewMutationList> cleanups_;
+  mutable std::unordered_map<SurfaceId, Window> windows_;
+  
+  std::unordered_map<Tag, UpdateValues>& getUpdateMap(SurfaceId surfaceId){
+    auto props = props_.find(surfaceId);
+    if (props != props_.end()){
+      return *props->second;
+    }
+    
+    auto newProps = std::make_shared<std::unordered_map<Tag, UpdateValues>>();
+    props_.insert_or_assign(surfaceId, newProps);
+    return *newProps;
+  }
+  
+  void updateWindow(SurfaceId surfaceId, double windowWidth, double windowHeight){
+    windows_.insert_or_assign(surfaceId, Window{windowWidth, windowHeight});
+  }
+  
+  Window getWindow(SurfaceId surfaceId){
+    auto windowIt = windows_.find(surfaceId);
+    if (windowIt != windows_.end()){
+      return windowIt->second;
+    }
+    return Window{0,0};
+  }
+  
+  void consumeCleanupMutations(SurfaceId surfaceId, ShadowViewMutationList& mutations){
+    for (auto& mutation: cleanups_[surfaceId]){
+      mutations.push_back(mutation);
+    }
+    cleanups_.erase(surfaceId);
+  }
+  
+  ShadowViewMutationList& getCleanupMutations(SurfaceId surfaceId){
+    return cleanups_[surfaceId];
+  }
+};
+
+static inline void updateLayoutMetrics(LayoutMetrics& layoutMetrics, Frame& frame){
+  if (frame.width) {
+    layoutMetrics.frame.size.width = *frame.width;
+  }
+  if (frame.height) {
+    layoutMetrics.frame.size.height = *frame.height;
+  }
+  if (frame.x) {
+    layoutMetrics.frame.origin.x = *frame.x;
+  }
+  if (frame.y) {
+    layoutMetrics.frame.origin.y = *frame.y;
+  }
+}

package/Common/cpp/NativeModules/NativeReanimatedModule.cpp

@@ -1,9 +1,6 @@
 #include "NativeReanimatedModule.h"
 
 #ifdef RCT_NEW_ARCH_ENABLED
-#if REACT_NATIVE_MINOR_VERSION >= 72
-#include <react/renderer/core/TraitCast.h>
-#endif
 #include <react/renderer/uimanager/UIManagerBinding.h>
 #include <react/renderer/uimanager/primitives.h>
 #if REACT_NATIVE_MINOR_VERSION >= 73 && defined(RCT_NEW_ARCH_ENABLED)
@@ -12,11 +9,15 @@
 #endif
 
 #include <functional>
+#include <iomanip>
 #include <memory>
+#include <sstream>
+#include <string>
 #include <thread>
 #include <unordered_map>
 
 #ifdef RCT_NEW_ARCH_ENABLED
+#include <react/renderer/scheduler/Scheduler.h>
 #include "ReanimatedCommitMarker.h"
 #include "ShadowTreeCloner.h"
 #endif
@@ -26,6 +27,7 @@
 #include "EventHandlerRegistry.h"
 #include "FeaturesConfig.h"
 #include "JSScheduler.h"
+#include "NativeReanimatedModule.h"
 #include "ReanimatedHiddenHeaders.h"
 #include "Shareables.h"
 #include "UIRuntimeDecorator.h"
@@ -37,7 +39,7 @@
 
 using namespace facebook;
 
-#if REACT_NATIVE_MINOR_VERSION >= 73 && defined(RCT_NEW_ARCH_ENABLED)
+#if REACT_NATIVE_MINOR_VERSION == 73 && defined(RCT_NEW_ARCH_ENABLED)
 // Android can't find the definition of this static field
 bool CoreFeatures::useNativeState;
 #endif
@@ -46,14 +48,17 @@ namespace reanimated {
 
 NativeReanimatedModule::NativeReanimatedModule(
     jsi::Runtime &rnRuntime,
-    const std::shared_ptr<CallInvoker> &jsInvoker,
+    const std::shared_ptr<JSScheduler> &jsScheduler,
     const std::shared_ptr<MessageQueueThread> &jsQueue,
     const std::shared_ptr<UIScheduler> &uiScheduler,
     const PlatformDepMethodsHolder &platformDepMethodsHolder,
-    const std::string &valueUnpackerCode)
-    : NativeReanimatedModuleSpec(jsInvoker),
+    const std::string &valueUnpackerCode,
+    const bool isBridgeless)
+    : NativeReanimatedModuleSpec(
+          isBridgeless ? nullptr : jsScheduler->getJSCallInvoker()),
+      isBridgeless_(isBridgeless),
       jsQueue_(jsQueue),
-      jsScheduler_(std::make_shared<JSScheduler>(rnRuntime, jsInvoker)),
+      jsScheduler_(jsScheduler),
       uiScheduler_(uiScheduler),
       uiWorkletRuntime_(std::make_shared<WorkletRuntime>(
           rnRuntime,
@@ -71,7 +76,7 @@ NativeReanimatedModule::NativeReanimatedModule(
       }),
       animatedSensorModule_(platformDepMethodsHolder),
       jsLogger_(std::make_shared<JSLogger>(jsScheduler_)),
-      layoutAnimationsManager_(jsLogger_),
+      layoutAnimationsManager_(std::make_shared<LayoutAnimationsManager>(jsLogger_)),
 #ifdef RCT_NEW_ARCH_ENABLED
       synchronouslyUpdateUIPropsFunction_(
           platformDepMethodsHolder.synchronouslyUpdateUIPropsFunction),
@@ -86,6 +91,11 @@ NativeReanimatedModule::NativeReanimatedModule(
           platformDepMethodsHolder.subscribeForKeyboardEvents),
       unsubscribeFromKeyboardEventsFunction_(
           platformDepMethodsHolder.unsubscribeFromKeyboardEvents) {
+  commonInit(platformDepMethodsHolder);
+}
+
+void NativeReanimatedModule::commonInit(
+    const PlatformDepMethodsHolder &platformDepMethodsHolder) {
   auto requestAnimationFrame =
       [this](jsi::Runtime &rt, const jsi::Value &callback) {
         this->requestAnimationFrame(rt, callback);
@@ -112,6 +122,42 @@ NativeReanimatedModule::NativeReanimatedModule(
                              const jsi::Value &argsValue) {
     this->dispatchCommand(rt, shadowNodeValue, commandNameValue, argsValue);
   };
+ProgressLayoutAnimationFunction progressLayoutAnimation =
+  [this](jsi::Runtime &rt, int tag, const jsi::Object &newStyle, bool) {
+    
+    auto surfaceId = layoutAnimationsProxy_->progressLayoutAnimation(tag, newStyle);
+    if (!surfaceId){
+      return;
+    }
+    
+    uiManager_->getShadowTreeRegistry().enumerate(
+      [surfaceId](const ShadowTree &shadowTree, bool &stop) {
+        if (shadowTree.getSurfaceId() == surfaceId){
+          shadowTree.notifyDelegatesOfUpdates();
+          stop = true;
+        }
+      });
+  };
+  
+EndLayoutAnimationFunction endLayoutAnimation =
+  [this](int tag, bool shouldRemove) {
+    auto surfaceId = layoutAnimationsProxy_->endLayoutAnimation(tag, shouldRemove);
+    uiManager_->getShadowTreeRegistry().enumerate(
+      [surfaceId](const ShadowTree &shadowTree, bool &stop) {
+        if (shadowTree.getSurfaceId() == surfaceId){
+          shadowTree.notifyDelegatesOfUpdates();
+          stop = true;
+        }
+      });
+  };
+        
+
+  auto obtainProp = [this](
+                        jsi::Runtime &rt,
+                        const jsi::Value &shadowNodeWrapper,
+                        const jsi::Value &propName) {
+    return this->obtainProp(rt, shadowNodeWrapper, propName);
+  };
 #endif
 
   jsi::Runtime &uiRuntime = uiWorkletRuntime_->getJSIRuntime();
@@ -119,11 +165,13 @@ NativeReanimatedModule::NativeReanimatedModule(
       uiRuntime,
 #ifdef RCT_NEW_ARCH_ENABLED
       removeFromPropsRegistry,
+      obtainProp,
       updateProps,
       measure,
       dispatchCommand,
 #else
       platformDepMethodsHolder.scrollToFunction,
+      platformDepMethodsHolder.obtainPropFunction,
       platformDepMethodsHolder.updatePropsFunction,
       platformDepMethodsHolder.measureFunction,
       platformDepMethodsHolder.dispatchCommandFunction,
@@ -131,8 +179,13 @@ NativeReanimatedModule::NativeReanimatedModule(
       requestAnimationFrame,
       platformDepMethodsHolder.getAnimationTimestamp,
       platformDepMethodsHolder.setGestureStateFunction,
+#ifdef RCT_NEW_ARCH_ENABLED
+            progressLayoutAnimation,
+            endLayoutAnimation,
+#else
       platformDepMethodsHolder.progressLayoutAnimation,
       platformDepMethodsHolder.endLayoutAnimation,
+#endif
       platformDepMethodsHolder.maybeFlushUIUpdatesQueueFunction);
 }
 
@@ -196,8 +249,10 @@ jsi::Value NativeReanimatedModule::scheduleOnRuntime(
 jsi::Value NativeReanimatedModule::makeShareableClone(
     jsi::Runtime &rt,
     const jsi::Value &value,
-    const jsi::Value &shouldRetainRemote) {
-  return reanimated::makeShareableClone(rt, value, shouldRetainRemote);
+    const jsi::Value &shouldRetainRemote,
+    const jsi::Value &nativeStateSource) {
+  return reanimated::makeShareableClone(
+      rt, value, shouldRetainRemote, nativeStateSource);
 }
 
 jsi::Value NativeReanimatedModule::registerEventHandler(
@@ -230,23 +285,102 @@ void NativeReanimatedModule::unregisterEventHandler(
       [=] { eventHandlerRegistry_->unregisterEventHandler(id); });
 }
 
+#ifdef RCT_NEW_ARCH_ENABLED
+static inline std::string intColorToHex(const int val) {
+  std::stringstream
+      invertedHexColorStream; // By default transparency is first, color second
+  invertedHexColorStream << std::setfill('0') << std::setw(8) << std::hex
+                         << val;
+
+  auto invertedHexColor = invertedHexColorStream.str();
+  auto hexColor =
+      "#" + invertedHexColor.substr(2, 6) + invertedHexColor.substr(0, 2);
+
+  return hexColor;
+}
+
+std::string NativeReanimatedModule::obtainPropFromShadowNode(
+    jsi::Runtime &rt,
+    const std::string &propName,
+    const ShadowNode::Shared &shadowNode) {
+  auto newestCloneOfShadowNode =
+      uiManager_->getNewestCloneOfShadowNode(*shadowNode);
+
+  if (propName == "width" || propName == "height" || propName == "top" ||
+      propName == "left") {
+    // These props are calculated from frame
+    auto layoutableShadowNode = dynamic_cast<LayoutableShadowNode const *>(
+        newestCloneOfShadowNode.get());
+    const auto &frame = layoutableShadowNode->layoutMetrics_.frame;
+
+    if (propName == "width") {
+      return std::to_string(frame.size.width);
+    } else if (propName == "height") {
+      return std::to_string(frame.size.height);
+    } else if (propName == "top") {
+      return std::to_string(frame.origin.y);
+    } else if (propName == "left") {
+      return std::to_string(frame.origin.x);
+    }
+  } else {
+    // These props are calculated from viewProps
+    auto props = newestCloneOfShadowNode->getProps();
+    auto viewProps = std::static_pointer_cast<const ViewProps>(props);
+    if (propName == "opacity") {
+      return std::to_string(viewProps->opacity);
+    } else if (propName == "zIndex") {
+      if (viewProps->zIndex.has_value()) {
+        return std::to_string(*viewProps->zIndex);
+      }
+    } else if (propName == "backgroundColor") {
+      return intColorToHex(*viewProps->backgroundColor);
+    }
+  }
+
+  throw std::runtime_error(std::string(
+      "Getting property `" + propName +
+      "` with function `getViewProp` is not supported"));
+}
+
 jsi::Value NativeReanimatedModule::getViewProp(
     jsi::Runtime &rnRuntime,
-    const jsi::Value &viewTag,
+    const jsi::Value &shadowNodeWrapper,
     const jsi::Value &propName,
     const jsi::Value &callback) {
-#ifdef RCT_NEW_ARCH_ENABLED
-  throw std::runtime_error(
-      "[Reanimated] getViewProp is not implemented on Fabric yet");
+  const auto propNameStr = propName.asString(rnRuntime).utf8(rnRuntime);
+  const auto funPtr = std::make_shared<jsi::Function>(
+      callback.getObject(rnRuntime).asFunction(rnRuntime));
+  const auto shadowNode = shadowNodeFromValue(rnRuntime, shadowNodeWrapper);
+  uiScheduler_->scheduleOnUI([=]() {
+    jsi::Runtime &uiRuntime = uiWorkletRuntime_->getJSIRuntime();
+    const auto resultStr =
+        obtainPropFromShadowNode(uiRuntime, propNameStr, shadowNode);
+
+    jsScheduler_->scheduleOnJS([=](jsi::Runtime &rnRuntime) {
+      const auto resultValue =
+          jsi::String::createFromUtf8(rnRuntime, resultStr);
+      funPtr->call(rnRuntime, resultValue);
+    });
+  });
+  return jsi::Value::undefined();
+}
+
 #else
-  const int viewTagInt = viewTag.asNumber();
+
+jsi::Value NativeReanimatedModule::getViewProp(
+    jsi::Runtime &rnRuntime,
+    const jsi::Value &viewTag,
+    const jsi::Value &propName,
+    const jsi::Value &callback) {
   const auto propNameStr = propName.asString(rnRuntime).utf8(rnRuntime);
   const auto funPtr = std::make_shared<jsi::Function>(
       callback.getObject(rnRuntime).asFunction(rnRuntime));
 
+  const int viewTagInt = viewTag.asNumber();
+
   uiScheduler_->scheduleOnUI([=]() {
     jsi::Runtime &uiRuntime = uiWorkletRuntime_->getJSIRuntime();
-    const auto propNameValue =
+    const jsi::Value propNameValue =
         jsi::String::createFromUtf8(uiRuntime, propNameStr);
     const auto resultValue =
         obtainPropFunction_(uiRuntime, viewTagInt, propNameValue);
@@ -258,11 +392,11 @@ jsi::Value NativeReanimatedModule::getViewProp(
       funPtr->call(rnRuntime, resultValue);
     });
   });
-
   return jsi::Value::undefined();
-#endif
 }
 
+#endif
+
 jsi::Value NativeReanimatedModule::enableLayoutAnimations(
     jsi::Runtime &,
     const jsi::Value &config) {
@@ -293,23 +427,6 @@ jsi::Value NativeReanimatedModule::configureProps(
   return jsi::Value::undefined();
 }
 
-jsi::Value NativeReanimatedModule::configureLayoutAnimation(
-    jsi::Runtime &rt,
-    const jsi::Value &viewTag,
-    const jsi::Value &type,
-    const jsi::Value &sharedTransitionTag,
-    const jsi::Value &config) {
-  layoutAnimationsManager_.configureAnimation(
-      viewTag.asNumber(),
-      static_cast<LayoutAnimationType>(type.asNumber()),
-      sharedTransitionTag.asString(rt).utf8(rt),
-      extractShareableOrThrow<ShareableObject>(
-          rt,
-          config,
-          "[Reanimated] Layout animation config must be an object."));
-  return jsi::Value::undefined();
-}
-
 jsi::Value NativeReanimatedModule::configureLayoutAnimationBatch(
     jsi::Runtime &rt,
     const jsi::Value &layoutAnimationsBatch) {
@@ -331,8 +448,18 @@ jsi::Value NativeReanimatedModule::configureLayoutAnimationBatch(
           config,
           "[Reanimated] Layout animation config must be an object.");
     }
+    if (batch[i].type != SHARED_ELEMENT_TRANSITION &&
+        batch[i].type != SHARED_ELEMENT_TRANSITION_PROGRESS) {
+      continue;
+    }
+    auto sharedTransitionTag = item.getProperty(rt, "sharedTransitionTag");
+    if (sharedTransitionTag.isUndefined()) {
+      batch[i].config = nullptr;
+    } else {
+      batch[i].sharedTransitionTag = sharedTransitionTag.asString(rt).utf8(rt);
+    }
   }
-  layoutAnimationsManager_.configureAnimationBatch(batch);
+  layoutAnimationsManager_->configureAnimationBatch(batch);
   return jsi::Value::undefined();
 }
 
@@ -340,7 +467,7 @@ void NativeReanimatedModule::setShouldAnimateExiting(
     jsi::Runtime &rt,
     const jsi::Value &viewTag,
     const jsi::Value &shouldAnimate) {
-  layoutAnimationsManager_.setShouldAnimateExiting(
+  layoutAnimationsManager_->setShouldAnimateExiting(
       viewTag.asNumber(), shouldAnimate.getBool());
 }
 
@@ -461,10 +588,11 @@ bool NativeReanimatedModule::handleRawEvent(
     double currentTime) {
   const EventTarget *eventTarget = rawEvent.eventTarget.get();
   if (eventTarget == nullptr) {
-    // after app reload scrollview is unmounted and its content offset is set to
-    // 0 and view is thrown into recycle pool setting content offset triggers
-    // scroll event eventTarget is null though, because it's unmounting we can
-    // just ignore this event, because it's an event on unmounted component
+    // after app reload scrollView is unmounted and its content offset is set
+    // to 0 and view is thrown into recycle pool setting content offset
+    // triggers scroll event eventTarget is null though, because it's
+    // unmounting we can just ignore this event, because it's an event on
+    // unmounted component
     return false;
   }
 
@@ -485,8 +613,8 @@ bool NativeReanimatedModule::handleRawEvent(
   auto res = handleEvent(eventType, tag, std::move(payload), currentTime);
   // TODO: we should call performOperations conditionally if event is handled
   // (res == true), but for now handleEvent always returns false. Thankfully,
-  // performOperations does not trigger a lot of code if there is nothing to be
-  // done so this is fine for now.
+  // performOperations does not trigger a lot of code if there is nothing to
+  // be done so this is fine for now.
   performOperations();
   return res;
 }
@@ -531,8 +659,8 @@ void NativeReanimatedModule::performOperations() {
       tagsToRemove_.clear();
     }
 
-    // Even if only non-layout props are changed, we need to store the update in
-    // PropsRegistry anyway so that React doesn't overwrite it in the next
+    // Even if only non-layout props are changed, we need to store the update
+    // in PropsRegistry anyway so that React doesn't overwrite it in the next
     // render. Currently, only opacity and transform are treated in a special
     // way but backgroundColor, shadowOpacity etc. would get overwritten (see
     // `_propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN`).
@@ -578,9 +706,9 @@ void NativeReanimatedModule::performOperations() {
   if (propsRegistry_->shouldReanimatedSkipCommit()) {
     // It may happen that `performOperations` is called on the UI thread
     // while React Native tries to commit a new tree on the JS thread.
-    // In this case, we should skip the commit here and let React Native do it.
-    // The commit will include the current values from PropsRegistry
-    // which will be applied in ReanimatedCommitHook.
+    // In this case, we should skip the commit here and let React Native do
+    // it. The commit will include the current values from PropsRegistry which
+    // will be applied in ReanimatedCommitHook.
     return;
   }
 
@@ -603,9 +731,10 @@ void NativeReanimatedModule::performOperations() {
             react_native_assert(family.getSurfaceId() == surfaceId_);
 
 #if REACT_NATIVE_MINOR_VERSION >= 73
-            // Fix for catching nullptr returned from commit hook was introduced
-            // in 0.72.4 but we have only check for minor version of React
-            // Native so enable that optimization in React Native >= 0.73
+            // Fix for catching nullptr returned from commit hook was
+            // introduced in 0.72.4 but we have only check for minor version
+            // of React Native so enable that optimization in React Native >=
+            // 0.73
             if (propsRegistry_->shouldReanimatedSkipCommit()) {
               return nullptr;
             }
@@ -659,6 +788,18 @@ void NativeReanimatedModule::dispatchCommand(
   uiManager_->dispatchCommand(shadowNode, commandName, args);
 }
 
+jsi::String NativeReanimatedModule::obtainProp(
+    jsi::Runtime &rt,
+    const jsi::Value &shadowNodeWrapper,
+    const jsi::Value &propName) {
+  jsi::Runtime &uiRuntime = uiWorkletRuntime_->getJSIRuntime();
+  const auto propNameStr = propName.asString(rt).utf8(rt);
+  const auto shadowNode = shadowNodeFromValue(rt, shadowNodeWrapper);
+  const auto resultStr =
+      obtainPropFromShadowNode(uiRuntime, propNameStr, shadowNode);
+  return jsi::String::createFromUtf8(rt, resultStr);
+}
+
 jsi::Value NativeReanimatedModule::measure(
     jsi::Runtime &rt,
     const jsi::Value &shadowNodeValue) {
@@ -669,9 +810,9 @@ jsi::Value NativeReanimatedModule::measure(
       *shadowNode, nullptr, {/* .includeTransform = */ true});
 
   if (layoutMetrics == EmptyLayoutMetrics) {
-    // Originally, in this case React Native returns `{0, 0, 0, 0, 0, 0}`, most
-    // likely due to the type of measure callback function which accepts just an
-    // array of numbers (not null). In Reanimated, `measure` returns
+    // Originally, in this case React Native returns `{0, 0, 0, 0, 0, 0}`,
+    // most likely due to the type of measure callback function which accepts
+    // just an array of numbers (not null). In Reanimated, `measure` returns
     // `MeasuredDimensions | null`.
     return jsi::Value::null();
   }
@@ -679,7 +820,7 @@ jsi::Value NativeReanimatedModule::measure(
       uiManager_->getNewestCloneOfShadowNode(*shadowNode);
 
   auto layoutableShadowNode =
-      traitCast<LayoutableShadowNode const *>(newestCloneOfShadowNode.get());
+      dynamic_cast<LayoutableShadowNode const *>(newestCloneOfShadowNode.get());
   facebook::react::Point originRelativeToParent =
       layoutableShadowNode != nullptr
       ? layoutableShadowNode->getLayoutMetrics().frame.origin
@@ -706,8 +847,25 @@ jsi::Value NativeReanimatedModule::measure(
 void NativeReanimatedModule::initializeFabric(
     const std::shared_ptr<UIManager> &uiManager) {
   uiManager_ = uiManager;
-  commitHook_ =
-      std::make_shared<ReanimatedCommitHook>(propsRegistry_, uiManager_);
+  uiManager->setAnimationDelegate(nullptr);
+    Scheduler *scheduler = (Scheduler *)uiManager->getDelegate();
+    auto cdr = scheduler->getContextContainer()
+                   ->at<std::weak_ptr<const ComponentDescriptorRegistry>>(
+                       "ComponentDescriptorRegistry_DO_NOT_USE_PRETTY_PLEASE");
+
+    layoutAnimationsProxy_ = std::make_shared<LayoutAnimationsProxy>(
+        layoutAnimationsManager_,
+        this,
+        cdr.lock(),
+        scheduler->getContextContainer());
+    uiManager->getShadowTreeRegistry().enumerate(
+        [this](const ShadowTree &shadowTree, bool &stop) {
+          shadowTree.getMountingCoordinator()->setMountingOverrideDelegate(
+              layoutAnimationsProxy_);
+        });
+
+    commitHook_ = std::make_shared<ReanimatedCommitHook>(
+        propsRegistry_, uiManager_);
 #if REACT_NATIVE_MINOR_VERSION >= 73
   mountHook_ =
       std::make_shared<ReanimatedMountHook>(propsRegistry_, uiManager_);