react-native-reanimated 4.3.0 → 4.3.2

package/Common/cpp/reanimated/CSS/interpolation/transforms/TransformOperationInterpolator.cpp

@@ -5,6 +5,8 @@
 #include <reanimated/CSS/interpolation/transforms/operations/skew.h>
 #include <reanimated/CSS/interpolation/transforms/operations/translate.h>
 
+#include <cmath>
+#include <limits>
 #include <utility>
 
 namespace reanimated::css {
@@ -31,14 +33,19 @@ std::unique_ptr<StyleOperation> TransformOperationInterpolator<PerspectiveOperat
     const std::shared_ptr<StyleOperation> &from,
     const std::shared_ptr<StyleOperation> &to,
     const StyleOperationsInterpolationContext & /* context */) const {
-  // TODO - check if this implementation is correct
   const auto &fromValue = std::static_pointer_cast<PerspectiveOperation>(from)->value;
   const auto &toValue = std::static_pointer_cast<PerspectiveOperation>(to)->value;
 
-  if (fromValue.value == 0)
-    return std::make_unique<PerspectiveOperation>(toValue);
-  if (toValue.value == 0)
-    return std::make_unique<PerspectiveOperation>(fromValue);
+  // The default "no perspective" is infinity, so interpolating the distance
+  // directly gives inf + t*(d - inf) = NaN. Interpolate in reciprocal space
+  // instead (1/inf = 0, matching how perspective enters the matrix as -1/d).
+  if (std::isinf(fromValue.value) || std::isinf(toValue.value)) {
+    const double fromReciprocal = 1.0 / fromValue.value;
+    const double toReciprocal = 1.0 / toValue.value;
+    const double reciprocal = fromReciprocal + progress * (toReciprocal - fromReciprocal);
+    return std::make_unique<PerspectiveOperation>(
+        reciprocal == 0.0 ? std::numeric_limits<double>::infinity() : 1.0 / reciprocal);
+  }
 
   return std::make_unique<PerspectiveOperation>(fromValue.interpolate(progress, toValue));
 }

package/Common/cpp/reanimated/CSS/misc/ViewStylesRepository.cpp

@@ -13,13 +13,11 @@ ViewStylesRepository::ViewStylesRepository(
 jsi::Value ViewStylesRepository::getNodeProp(
     const std::shared_ptr<const ShadowNode> &shadowNode,
     const std::string &propName) {
-  int tag = shadowNode->getTag();
-
-  auto &cachedNode = shadowNodeCache_[tag];
-  updateCacheIfNeeded(cachedNode, shadowNode);
+  const auto resolvedNode = getNewestNode(shadowNode);
+  const auto *layoutableShadowNode = dynamic_cast<const LayoutableShadowNode *>(resolvedNode.get());
 
   if (propName == "width" || propName == "height" || propName == "top" || propName == "left") {
-    const auto &layoutMetrics = cachedNode.layoutMetrics;
+    const auto layoutMetrics = layoutableShadowNode ? layoutableShadowNode->layoutMetrics_ : LayoutMetrics{};
 
     if (propName == "width") {
       return {layoutMetrics.frame.size.width};
@@ -31,7 +29,13 @@ jsi::Value ViewStylesRepository::getNodeProp(
       return {layoutMetrics.frame.origin.x};
     }
   } else {
-    const auto &viewProps = cachedNode.viewProps;
+    if (!layoutableShadowNode) {
+      return jsi::Value::undefined();
+    }
+    const auto viewProps = std::static_pointer_cast<const ViewProps>(resolvedNode->getProps());
+    if (!viewProps) {
+      return jsi::Value::undefined();
+    }
 
     if (propName == "opacity") {
       return {viewProps->opacity};
@@ -48,15 +52,7 @@ jsi::Value ViewStylesRepository::getNodeProp(
 jsi::Value ViewStylesRepository::getParentNodeProp(
     const std::shared_ptr<const ShadowNode> &shadowNode,
     const std::string &propName) {
-  const auto surfaceId = shadowNode->getSurfaceId();
-  const auto &shadowTreeRegistry = uiManager_->getShadowTreeRegistry();
-
-  std::shared_ptr<const ShadowNode> parentNode = nullptr;
-
-  shadowTreeRegistry.visit(surfaceId, [&](ShadowTree const &shadowTree) {
-    auto currentRevision = shadowTree.getCurrentRevision();
-    parentNode = dom::getParentNode(currentRevision.rootShadowNode, *shadowNode);
-  });
+  const auto parentNode = getParentNode(shadowNode);
 
   if (!parentNode) {
     return jsi::Value::undefined();
@@ -65,37 +61,63 @@ jsi::Value ViewStylesRepository::getParentNodeProp(
   return getNodeProp(parentNode, propName);
 }
 
-folly::dynamic ViewStylesRepository::getStyleProp(const Tag tag, const PropertyPath &propertyPath) {
-  auto animatedValue = getPropertyValue(animatedPropsRegistry_->get(tag), propertyPath);
-  if (!animatedValue.isNull()) {
-    return animatedValue;
+std::shared_ptr<const ShadowNode> ViewStylesRepository::getNewestNode(
+    const std::shared_ptr<const ShadowNode> &shadowNode) const {
+  // Resolve shadowNode against the last mounted root instead of reading the live
+  // ShadowTree: uiManager_->getNewestCloneOfShadowNode takes the ShadowTree commit
+  // lock, and this method runs under the updates-registry lock while a concurrent
+  // Fabric commit takes the same two locks in the opposite order (the ANR
+  // deadlock). Falls back to the passed node. Mirrors RN's getShadowNodeInSubtree:
+  // https://github.com/facebook/react-native/blob/v0.86.0-rc.3/packages/react-native/ReactCommon/react/renderer/uimanager/UIManager.cpp#L339
+  RootShadowNode::Shared root;
+  {
+    const std::lock_guard<std::mutex> lock{lastMountedRootMutex_};
+    const auto it = lastMountedRootBySurface_.find(shadowNode->getSurfaceId());
+    if (it == lastMountedRootBySurface_.end()) {
+      return shadowNode;
+    }
+    root = it->second;
   }
 
-  return getPropertyValue(staticPropsRegistry_->get(tag), propertyPath);
-}
+  if (ShadowNode::sameFamily(*root, *shadowNode)) {
+    return root;
+  }
 
-void ViewStylesRepository::clearNodesCache() {
-  shadowNodeCache_.clear();
-}
+  const auto ancestors = shadowNode->getFamily().getAncestors(*root);
+  if (ancestors.empty()) {
+    return shadowNode;
+  }
 
-void ViewStylesRepository::updateCacheIfNeeded(
-    CachedShadowNode &cachedNode,
-    const std::shared_ptr<const ShadowNode> &shadowNode) {
-  auto newestCloneOfShadowNode = uiManager_->getNewestCloneOfShadowNode(*shadowNode);
+  const auto &deepest = ancestors.back();
+  return deepest.first.get().getChildren().at(deepest.second);
+}
 
-  // Check if newestCloneOfShadowNode is valid (is already mounted / not
-  // yet unmounted)
-  if (!newestCloneOfShadowNode) {
-    return;
+std::shared_ptr<const ShadowNode> ViewStylesRepository::getParentNode(
+    const std::shared_ptr<const ShadowNode> &shadowNode) const {
+  RootShadowNode::Shared root;
+  {
+    const std::lock_guard<std::mutex> lock{lastMountedRootMutex_};
+    const auto it = lastMountedRootBySurface_.find(shadowNode->getSurfaceId());
+    if (it == lastMountedRootBySurface_.end()) {
+      return nullptr;
+    }
+    root = it->second;
   }
+  return dom::getParentNode(root, *shadowNode);
+}
+
+void ViewStylesRepository::setLastMountedRoot(const RootShadowNode::Shared &rootShadowNode) {
+  const std::lock_guard<std::mutex> lock{lastMountedRootMutex_};
+  lastMountedRootBySurface_[rootShadowNode->getSurfaceId()] = rootShadowNode;
+}
 
-  auto layoutableShadowNode = dynamic_cast<const LayoutableShadowNode *>(newestCloneOfShadowNode.get());
-  if (!layoutableShadowNode) {
-    return;
+folly::dynamic ViewStylesRepository::getStyleProp(const Tag tag, const PropertyPath &propertyPath) {
+  auto animatedValue = getPropertyValue(animatedPropsRegistry_->get(tag), propertyPath);
+  if (!animatedValue.isNull()) {
+    return animatedValue;
   }
 
-  cachedNode.layoutMetrics = layoutableShadowNode->layoutMetrics_;
-  cachedNode.viewProps = std::static_pointer_cast<const ViewProps>(newestCloneOfShadowNode->getProps());
+  return getPropertyValue(staticPropsRegistry_->get(tag), propertyPath);
 }
 
 folly::dynamic ViewStylesRepository::getPropertyValue(const folly::dynamic &value, const PropertyPath &propertyPath) {

package/Common/cpp/reanimated/CSS/misc/ViewStylesRepository.h

@@ -4,11 +4,14 @@
 #include <reanimated/CSS/registries/StaticPropsRegistry.h>
 #include <reanimated/Fabric/updates/AnimatedPropsRegistry.h>
 
+#include <react/renderer/components/root/RootShadowNode.h>
 #include <react/renderer/components/view/ViewProps.h>
 #include <react/renderer/core/LayoutableShadowNode.h>
 #include <react/renderer/dom/DOM.h>
+#include <react/renderer/uimanager/UIManager.h>
 
 #include <memory>
+#include <mutex>
 #include <string>
 #include <unordered_map>
 
@@ -17,11 +20,6 @@ namespace reanimated::css {
 using namespace facebook;
 using namespace react;
 
-struct CachedShadowNode {
-  LayoutMetrics layoutMetrics;
-  std::shared_ptr<const ViewProps> viewProps;
-};
-
 class ViewStylesRepository {
  public:
   ViewStylesRepository(
@@ -36,16 +34,21 @@ class ViewStylesRepository {
   jsi::Value getParentNodeProp(const std::shared_ptr<const ShadowNode> &shadowNode, const std::string &propName);
   folly::dynamic getStyleProp(Tag tag, const PropertyPath &propertyPath);
 
-  void clearNodesCache();
+  void setLastMountedRoot(const RootShadowNode::Shared &rootShadowNode);
 
  private:
   std::shared_ptr<UIManager> uiManager_;
   std::shared_ptr<StaticPropsRegistry> staticPropsRegistry_;
   std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry_;
 
-  std::unordered_map<int, CachedShadowNode> shadowNodeCache_;
+  // Transition setup resolves relative lengths on the JS thread without the
+  // updates-registry lock, while the mount hook records roots under it, so the
+  // map needs its own guard.
+  mutable std::mutex lastMountedRootMutex_;
+  std::unordered_map<SurfaceId, RootShadowNode::Shared> lastMountedRootBySurface_;
 
-  void updateCacheIfNeeded(CachedShadowNode &cachedNode, const std::shared_ptr<const ShadowNode> &shadowNode);
+  std::shared_ptr<const ShadowNode> getNewestNode(const std::shared_ptr<const ShadowNode> &shadowNode) const;
+  std::shared_ptr<const ShadowNode> getParentNode(const std::shared_ptr<const ShadowNode> &shadowNode) const;
 
   static folly::dynamic getPropertyValue(const folly::dynamic &value, const PropertyPath &propertyPath);
 };

package/Common/cpp/reanimated/CSS/registries/CSSAnimationsRegistry.cpp

@@ -9,12 +9,14 @@
 namespace reanimated::css {
 
 bool CSSAnimationsRegistry::isEmpty() const {
+  std::lock_guard<std::mutex> lock{mutex_};
   // The registry is empty if has no registered animations and no updates
   // stored in the updates registry
-  return UpdatesRegistry::isEmpty() && registry_.empty();
+  return updatesRegistry_.empty() && registry_.empty();
 }
 
 bool CSSAnimationsRegistry::hasUpdates() const {
+  std::lock_guard<std::mutex> lock{mutex_};
   return !runningAnimationIndicesMap_.empty() || !delayedAnimationsManager_.empty() || !animationsToRevertMap_.empty();
 }
 
@@ -25,11 +27,13 @@ void CSSAnimationsRegistry::apply(
     const CSSAnimationsMap &newAnimations,
     const CSSAnimationSettingsUpdatesMap &settingsUpdates,
     double timestamp) {
+  std::lock_guard<std::mutex> lock{mutex_};
+
   auto animationsVector = buildAnimationsVector(rt, shadowNode, animationNames, newAnimations);
 
   const auto viewTag = shadowNode->getTag();
   if (animationsVector.empty()) {
-    remove(viewTag);
+    removeTag(viewTag);
     return;
   }
 
@@ -56,7 +60,7 @@ void CSSAnimationsRegistry::apply(
   applyViewAnimationsStyle(viewTag, timestamp);
 }
 
-void CSSAnimationsRegistry::remove(const Tag viewTag) {
+void CSSAnimationsRegistry::removeTag(const Tag viewTag) {
   removeViewAnimations(viewTag);
   removeFromUpdatesRegistry(viewTag);
   registry_.erase(viewTag);
@@ -289,6 +293,10 @@ void CSSAnimationsRegistry::applyViewAnimationsStyle(const Tag viewTag, const do
   }
 
   setInUpdatesRegistry(shadowNode, updatedStyle);
+
+  if (shadowNode && !updatedStyle.empty()) {
+    addUpdatesToBatch(shadowNode, updatedStyle);
+  }
 }
 
 void CSSAnimationsRegistry::activateDelayedAnimations(const double timestamp) {

package/Common/cpp/reanimated/CSS/registries/CSSAnimationsRegistry.h

@@ -7,6 +7,7 @@
 #include <reanimated/Fabric/updates/UpdatesRegistry.h>
 
 #include <memory>
+#include <mutex>
 #include <set>
 #include <string>
 #include <unordered_map>
@@ -33,9 +34,12 @@ class CSSAnimationsRegistry : public UpdatesRegistry, std::enable_shared_from_th
       const CSSAnimationsMap &newAnimations,
       const CSSAnimationSettingsUpdatesMap &settingsUpdates,
       double timestamp);
-  void remove(Tag viewTag) override;
 
-  void update(double timestamp);
+  void updateAndFlush(double timestamp, UpdatesBatch &updatesBatch) {
+    std::lock_guard<std::mutex> lock{mutex_};
+    update(timestamp);
+    flush(updatesBatch);
+  }
 
  private:
   using AnimationToIndexMap = std::unordered_map<std::shared_ptr<CSSAnimation>, size_t>;
@@ -54,6 +58,9 @@ class CSSAnimationsRegistry : public UpdatesRegistry, std::enable_shared_from_th
   AnimationsToRevertMap animationsToRevertMap_;
   DelayedItemsManager<std::shared_ptr<CSSAnimation>> delayedAnimationsManager_;
 
+  void removeTag(Tag viewTag) override;
+  void update(double timestamp);
+
   CSSAnimationsVector buildAnimationsVector(
       jsi::Runtime &rt,
       const std::shared_ptr<const ShadowNode> &shadowNode,

package/Common/cpp/reanimated/CSS/registries/CSSTransitionsRegistry.cpp

@@ -11,12 +11,14 @@ CSSTransitionsRegistry::CSSTransitionsRegistry(
     : getCurrentTimestamp_(getCurrentTimestamp), viewStylesRepository_(viewStylesRepository) {}
 
 bool CSSTransitionsRegistry::isEmpty() const {
+  std::lock_guard<std::mutex> lock{mutex_};
   // The registry is empty if has no registered animations and no updates
   // stored in the updates registry
-  return UpdatesRegistry::isEmpty() && registry_.empty();
+  return updatesRegistry_.empty() && registry_.empty();
 }
 
 bool CSSTransitionsRegistry::hasUpdates() const {
+  std::lock_guard<std::mutex> lock{mutex_};
   return !runningTransitionTags_.empty() || !delayedTransitionsManager_.empty();
 }
 
@@ -24,6 +26,8 @@ void CSSTransitionsRegistry::run(
     jsi::Runtime &rt,
     const std::shared_ptr<const ShadowNode> &shadowNode,
     const CSSTransitionConfig &config) {
+  std::lock_guard<std::mutex> lock{mutex_};
+
   const auto viewTag = shadowNode->getTag();
 
   if (!registry_.contains(viewTag)) {
@@ -42,7 +46,7 @@ void CSSTransitionsRegistry::run(
   updateInUpdatesRegistry(transition, initialUpdate);
 }
 
-void CSSTransitionsRegistry::remove(const Tag viewTag) {
+void CSSTransitionsRegistry::removeTag(const Tag viewTag) {
   removeFromUpdatesRegistry(viewTag);
   delayedTransitionsManager_.remove(viewTag);
   runningTransitionTags_.erase(viewTag);

package/Common/cpp/reanimated/CSS/registries/CSSTransitionsRegistry.h

@@ -8,6 +8,7 @@
 #include <reanimated/Tools/PlatformDepMethodsHolder.h>
 
 #include <memory>
+#include <mutex>
 #include <set>
 #include <unordered_map>
 #include <unordered_set>
@@ -26,9 +27,12 @@ class CSSTransitionsRegistry : public UpdatesRegistry, public std::enable_shared
   bool hasUpdates() const;
 
   void run(jsi::Runtime &rt, const std::shared_ptr<const ShadowNode> &shadowNode, const CSSTransitionConfig &config);
-  void remove(Tag viewTag) override;
 
-  void update(double timestamp);
+  void updateAndFlush(double timestamp, UpdatesBatch &updatesBatch) {
+    std::lock_guard<std::mutex> lock{mutex_};
+    update(timestamp);
+    flush(updatesBatch);
+  }
 
  private:
   using Registry = std::unordered_map<Tag, std::shared_ptr<CSSTransition>>;
@@ -41,6 +45,8 @@ class CSSTransitionsRegistry : public UpdatesRegistry, public std::enable_shared
   std::unordered_set<Tag> runningTransitionTags_;
   DelayedItemsManager<Tag> delayedTransitionsManager_;
 
+  void removeTag(Tag viewTag) override;
+  void update(double timestamp);
   void activateDelayedTransitions(double timestamp);
   void scheduleOrActivateTransition(const std::shared_ptr<CSSTransition> &transition);
   void updateInUpdatesRegistry(const std::shared_ptr<CSSTransition> &transition, const folly::dynamic &updates);

package/Common/cpp/reanimated/CSS/registries/StaticPropsRegistry.cpp

@@ -7,16 +7,26 @@ namespace reanimated::css {
 void StaticPropsRegistry::set(jsi::Runtime &rt, const Tag viewTag, const jsi::Value &props) {
   if (props.isNull() || props.isUndefined()) {
     remove(viewTag);
-  } else {
-    const auto newProps = dynamicFromValue(rt, props);
-    if (has(viewTag)) {
-      notifyObservers(viewTag, get(viewTag), newProps);
+    return;
+  }
+
+  const auto newProps = dynamicFromValue(rt, props);
+  folly::dynamic oldProps;
+  {
+    std::lock_guard<std::mutex> lock{mutex_};
+    const auto it = registry_.find(viewTag);
+    if (it != registry_.end()) {
+      oldProps = it->second;
     }
     registry_[viewTag] = newProps;
   }
+  if (!oldProps.isNull()) {
+    notifyObservers(viewTag, oldProps, newProps);
+  }
 }
 
 folly::dynamic StaticPropsRegistry::get(const Tag viewTag) const {
+  std::lock_guard<std::mutex> lock{mutex_};
   auto it = registry_.find(viewTag);
   if (it == registry_.end()) {
     return nullptr;
@@ -25,14 +35,17 @@ folly::dynamic StaticPropsRegistry::get(const Tag viewTag) const {
 }
 
 bool StaticPropsRegistry::has(const Tag viewTag) const {
+  std::lock_guard<std::mutex> lock{mutex_};
   return registry_.find(viewTag) != registry_.end();
 }
 
 void StaticPropsRegistry::remove(const Tag viewTag) {
+  std::lock_guard<std::mutex> lock{mutex_};
   registry_.erase(viewTag);
 }
 
 bool StaticPropsRegistry::isEmpty() const {
+  std::lock_guard<std::mutex> lock{mutex_};
   return registry_.empty() && observers_.empty();
 }
 

package/Common/cpp/reanimated/CSS/registries/StaticPropsRegistry.h

@@ -2,6 +2,7 @@
 
 #include <react/renderer/core/ShadowNode.h>
 
+#include <mutex>
 #include <unordered_map>
 
 namespace reanimated::css {
@@ -24,6 +25,10 @@ class StaticPropsRegistry {
   void removeObserver(Tag viewTag);
 
  private:
+  /// registry_ is written on the JS thread (setViewStyle) and read on the UI
+  /// thread during interpolation and on the commit/mount thread during node
+  /// removals, so it needs its own guard. observers_ is JS-thread-only.
+  mutable std::mutex mutex_;
   std::unordered_map<Tag, folly::dynamic> registry_;
   std::unordered_map<Tag, PropsObserver> observers_;
 

package/Common/cpp/reanimated/CSS/svg/values/SVGStrokeDashArray.cpp

@@ -43,6 +43,11 @@ bool SVGStrokeDashArray::canConstruct(const folly::dynamic &value) {
 }
 
 folly::dynamic SVGStrokeDashArray::toDynamic() const {
+  // Empty means "no dashing" - emit null instead of [], which react-native-svg
+  // would feed to Android's DashPathEffect that requires at least 2 intervals.
+  if (values.empty()) {
+    return nullptr;
+  }
   folly::dynamic array = folly::dynamic::array;
   array.reserve(values.size());
   for (const auto &value : values) {

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

@@ -9,8 +9,12 @@ namespace reanimated {
 ReanimatedMountHook::ReanimatedMountHook(
     const std::shared_ptr<UIManager> &uiManager,
     const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
+    const std::shared_ptr<css::ViewStylesRepository> &viewStylesRepository,
     const std::function<void()> &requestFlush)
-    : uiManager_(uiManager), updatesRegistryManager_(updatesRegistryManager), requestFlush_(requestFlush) {
+    : uiManager_(uiManager),
+      updatesRegistryManager_(updatesRegistryManager),
+      viewStylesRepository_(viewStylesRepository),
+      requestFlush_(requestFlush) {
   uiManager_->registerMountHook(*this);
 }
 
@@ -26,24 +30,33 @@ void ReanimatedMountHook::shadowTreeDidMount(
   auto reaShadowNode = std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(
       std::const_pointer_cast<RootShadowNode>(rootShadowNode));
 
-  if (reaShadowNode->hasReanimatedMountTrait()) {
-    // We mark reanimated commits with ReanimatedMountTrait. We don't want other
-    // shadow nodes to use this trait, but since this rootShadowNode is Shared,
-    // we don't have that guarantee. That's why we also unset this trait in the
-    // commit hook. We remove it here mainly for the sake of cleanliness.
+  // We mark reanimated commits with ReanimatedMountTrait. We don't want other
+  // shadow nodes to use this trait, but since this rootShadowNode is Shared,
+  // we don't have that guarantee. That's why we also unset this trait in the
+  // commit hook. We remove it here mainly for the sake of cleanliness.
+  const bool isReanimatedMount = reaShadowNode->hasReanimatedMountTrait();
+  if (isReanimatedMount) {
     reaShadowNode->unsetReanimatedMountTrait();
-    return;
   }
 
   {
     auto lock = updatesRegistryManager_->lock();
+    // Record the mounted tree for relative-length resolution.
+    viewStylesRepository_->setLastMountedRoot(rootShadowNode);
+
+    // Always drain removable nodes, even on Reanimated's own commits. While CSS
+    // animations run every mount carries the mount trait, so returning early here
+    // would skip removals for the whole animation and leak unmounted nodes if the
+    // tree is torn down mid-animation.
     updatesRegistryManager_->handleNodeRemovals(*rootShadowNode);
 
-    // When commit from React Native has finished, we reset the skip commit flag
-    // in order to allow Reanimated to commit its tree
-    updatesRegistryManager_->unpauseReanimatedCommits();
-    if (updatesRegistryManager_->shouldCommitAfterPause()) {
-      requestFlush_();
+    if (!isReanimatedMount) {
+      // When a commit from React Native has finished, we reset the skip commit
+      // flag in order to allow Reanimated to commit its tree.
+      updatesRegistryManager_->unpauseReanimatedCommits();
+      if (updatesRegistryManager_->shouldCommitAfterPause()) {
+        requestFlush_();
+      }
     }
   }
 }

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

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <reanimated/CSS/misc/ViewStylesRepository.h>
 #include <reanimated/Fabric/ShadowTreeCloner.h>
 #include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
 
@@ -16,6 +17,7 @@ class ReanimatedMountHook : public UIManagerMountHook {
   ReanimatedMountHook(
       const std::shared_ptr<UIManager> &uiManager,
       const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
+      const std::shared_ptr<css::ViewStylesRepository> &viewStylesRepository,
       const std::function<void()> &requestFlush);
   ~ReanimatedMountHook() noexcept override;
 
@@ -24,6 +26,7 @@ class ReanimatedMountHook : public UIManagerMountHook {
  private:
   const std::shared_ptr<UIManager> uiManager_;
   const std::shared_ptr<UpdatesRegistryManager> updatesRegistryManager_;
+  const std::shared_ptr<css::ViewStylesRepository> viewStylesRepository_;
   const std::function<void()> requestFlush_;
 };
 

package/Common/cpp/reanimated/Fabric/updates/AnimatedPropsRegistry.cpp

@@ -15,6 +15,7 @@ static inline std::shared_ptr<const ShadowNode> shadowNodeFromValue(
 void AnimatedPropsRegistry::update(jsi::Runtime &rt, const jsi::Value &operations, const double timestamp) {
   auto operationsArray = operations.asObject(rt).asArray(rt);
 
+  std::lock_guard<std::mutex> lock{mutex_};
   for (size_t i = 0, length = operationsArray.size(rt); i < length; ++i) {
     auto item = operationsArray.getValueAtIndex(rt, i).asObject(rt);
     auto shadowNodeWrapper = item.getProperty(rt, "shadowNodeWrapper");
@@ -29,12 +30,13 @@ void AnimatedPropsRegistry::update(jsi::Runtime &rt, const jsi::Value &operation
   }
 }
 
-void AnimatedPropsRegistry::remove(const Tag tag) {
-  updatesRegistry_.erase(tag);
-  timestampMap_.erase(tag);
-}
+jsi::Value AnimatedPropsRegistry::getUpdatesOlderThanTimestamp(
+    jsi::Runtime &rt,
+    const double timestamp,
+    const double cleanupTimestamp) {
+  std::lock_guard<std::mutex> lock{mutex_};
+  removeUpdatesOlderThanTimestamp(cleanupTimestamp);
 
-jsi::Value AnimatedPropsRegistry::getUpdatesOlderThanTimestamp(jsi::Runtime &rt, const double timestamp) {
   std::vector<std::pair<Tag, std::reference_wrapper<const folly::dynamic>>> updates;
 
   for (const auto &[viewTag, pair] : updatesRegistry_) {
@@ -69,4 +71,9 @@ void AnimatedPropsRegistry::removeUpdatesOlderThanTimestamp(const double timesta
   }
 }
 
+void AnimatedPropsRegistry::removeTag(const Tag tag) {
+  updatesRegistry_.erase(tag);
+  timestampMap_.erase(tag);
+}
+
 } // namespace reanimated

package/Common/cpp/reanimated/Fabric/updates/AnimatedPropsRegistry.h

@@ -14,12 +14,15 @@ namespace reanimated {
 class AnimatedPropsRegistry : public UpdatesRegistry {
  public:
   void update(jsi::Runtime &rt, const jsi::Value &operations, double timestamp);
-  void remove(Tag tag) override;
-  jsi::Value getUpdatesOlderThanTimestamp(jsi::Runtime &rt, double timestamp);
-  void removeUpdatesOlderThanTimestamp(double timestamp);
+
+  /// Also removes updates older than `cleanupTimestamp` from the registry.
+  jsi::Value getUpdatesOlderThanTimestamp(jsi::Runtime &rt, double timestamp, double cleanupTimestamp);
 
  private:
   std::unordered_map<Tag, double> timestampMap_; // viewTag -> timestamp, protected by `mutex_`
+
+  void removeUpdatesOlderThanTimestamp(double timestamp);
+  void removeTag(Tag tag) override;
 };
 
 } // namespace reanimated

package/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.cpp

@@ -8,11 +8,8 @@
 
 namespace reanimated {
 
-std::lock_guard<std::mutex> UpdatesRegistry::lock() const {
-  return std::lock_guard<std::mutex>{mutex_};
-}
-
 bool UpdatesRegistry::isEmpty() const {
+  std::lock_guard<std::mutex> lock{mutex_};
   return updatesRegistry_.empty();
 }
 
@@ -26,7 +23,7 @@ folly::dynamic UpdatesRegistry::get(const Tag tag) const {
   return it->second.second;
 }
 
-void UpdatesRegistry::flushUpdates(UpdatesBatch &updatesBatch) {
+void UpdatesRegistry::flush(UpdatesBatch &updatesBatch) {
   auto copiedUpdatesBatch = std::move(updatesBatch_);
   updatesBatch_.clear();
 
@@ -39,7 +36,7 @@ void UpdatesRegistry::flushUpdates(UpdatesBatch &updatesBatch) {
 }
 
 UpdatesBatch UpdatesRegistry::getPendingUpdates() {
-  auto lock = std::lock_guard<std::mutex>{mutex_};
+  std::lock_guard<std::mutex> lock{mutex_};
   flushUpdatesToRegistry(updatesBatch_);
 
   UpdatesBatch updatesBatch;
@@ -116,6 +113,7 @@ void UpdatesRegistry::flushUpdatesToRegistry(const UpdatesBatch &updatesBatch) {
 #ifdef ANDROID
 
 bool UpdatesRegistry::hasPropsToRevert() const {
+  std::lock_guard<std::mutex> lock{mutex_};
   return !propsToRevertMap_.empty();
 }