react-native 0.84.0-nightly-20251204-5bb3a6d68 → 0.84.0-nightly-20251206-63b0aef13

package/ReactCommon/react/renderer/animated/NativeAnimatedNodesManager.cpp

@@ -238,6 +238,20 @@ void NativeAnimatedNodesManager::connectAnimatedNodeToView(
   }
 }
 
+void NativeAnimatedNodesManager::connectAnimatedNodeToShadowNodeFamily(
+    Tag propsNodeTag,
+    std::shared_ptr<const ShadowNodeFamily> family) noexcept {
+  react_native_assert(propsNodeTag);
+  auto node = getAnimatedNode<PropsAnimatedNode>(propsNodeTag);
+  if (node != nullptr && family != nullptr) {
+    std::lock_guard<std::mutex> lock(tagToShadowNodeFamilyMutex_);
+    tagToShadowNodeFamily_[family->getTag()] = family;
+  } else {
+    LOG(WARNING)
+        << "Cannot ConnectAnimatedNodeToShadowNodeFamily, animated node has to be props type";
+  }
+}
+
 void NativeAnimatedNodesManager::disconnectAnimatedNodeFromView(
     Tag propsNodeTag,
     Tag viewTag) noexcept {
@@ -251,6 +265,10 @@ void NativeAnimatedNodesManager::disconnectAnimatedNodeFromView(
       std::lock_guard<std::mutex> lock(connectedAnimatedNodesMutex_);
       connectedAnimatedNodes_.erase(viewTag);
     }
+    {
+      std::lock_guard<std::mutex> lock(tagToShadowNodeFamilyMutex_);
+      tagToShadowNodeFamily_.erase(viewTag);
+    }
     updatedNodeTags_.insert(node->tag());
 
     onManagedPropsRemoved(viewTag);
@@ -705,7 +723,8 @@ void NativeAnimatedNodesManager::updateNodes(
     for (auto childTag : nextNode.node->getChildren()) {
       auto child = getAnimatedNode<AnimatedNode>(childTag);
       child->activeIncomingNodes--;
-      if (child->activeIncomingNodes == 0 && child->activeIncomingNodes == 0) {
+      if (child->activeIncomingNodes == 0 &&
+          child->bfsColor != animatedGraphBFSColor_) {
         child->bfsColor = animatedGraphBFSColor_;
 #ifdef REACT_NATIVE_DEBUG
         updatedNodesCount++;
@@ -985,15 +1004,47 @@ AnimationMutations NativeAnimatedNodesManager::pullAnimationMutations() {
       }
 
       for (auto& [tag, props] : updateViewPropsDirect_) {
-        // TODO: also handle layout props (updateViewProps_). It is skipped for
-        // now, because the backend requires shadowNodeFamilies to be able to
-        // commit to the ShadowTree
         propsBuilder.storeDynamic(props);
         mutations.push_back(
             AnimationMutation{tag, nullptr, propsBuilder.get()});
         containsChange = true;
       }
-      updateViewPropsDirect_.clear();
+      {
+        std::lock_guard<std::mutex> lock(tagToShadowNodeFamilyMutex_);
+        for (auto& [tag, props] : updateViewProps_) {
+          auto familyIt = tagToShadowNodeFamily_.find(tag);
+          if (familyIt == tagToShadowNodeFamily_.end()) {
+            continue;
+          }
+          if (auto family = familyIt->second.lock()) {
+            // C++ Animated produces props in the form of a folly::dynamic, so
+            // it wouldn't make sense to unpack it here. However, for the
+            // purposes of testing, we want to be able to use the statically
+            // typed AnimationMutation. At a later stage we will instead just
+            // pass the dynamic directly to propsBuilder and the new API could
+            // be used by 3rd party libraries or in the fututre by Animated.
+            if (props.find("width") != props.items().end()) {
+              propsBuilder.setWidth(
+                  yoga::Style::SizeLength::points(props["width"].asDouble()));
+            }
+            if (props.find("height") != props.items().end()) {
+              propsBuilder.setHeight(
+                  yoga::Style::SizeLength::points(props["height"].asDouble()));
+            }
+            mutations.push_back(
+                AnimationMutation{
+                    .tag = tag,
+                    .family = family,
+                    .props = propsBuilder.get(),
+                });
+          }
+          containsChange = true;
+        }
+      }
+      if (containsChange) {
+        updateViewPropsDirect_.clear();
+        updateViewProps_.clear();
+      }
     }
 
     if (!containsChange) {
@@ -1013,16 +1064,38 @@ AnimationMutations NativeAnimatedNodesManager::pullAnimationMutations() {
         }
       }
 
-      // Step 2: update all nodes that are connected to the finished animations.
+      // Step 2: update all nodes that are connected to the finished
+      // animations.
       updateNodes(finishedAnimationValueNodes);
 
       isEventAnimationInProgress_ = false;
 
       for (auto& [tag, props] : updateViewPropsDirect_) {
-        // TODO: handle layout props
         propsBuilder.storeDynamic(props);
         mutations.push_back(
-            AnimationMutation{tag, nullptr, propsBuilder.get()});
+            AnimationMutation{
+                .tag = tag,
+                .family = nullptr,
+                .props = propsBuilder.get(),
+            });
+      }
+      {
+        std::lock_guard<std::mutex> lock(tagToShadowNodeFamilyMutex_);
+        for (auto& [tag, props] : updateViewProps_) {
+          auto familyIt = tagToShadowNodeFamily_.find(tag);
+          if (familyIt == tagToShadowNodeFamily_.end()) {
+            continue;
+          }
+          if (auto family = familyIt->second.lock()) {
+            propsBuilder.storeDynamic(props);
+            mutations.push_back(
+                AnimationMutation{
+                    .tag = tag,
+                    .family = family,
+                    .props = propsBuilder.get(),
+                });
+          }
+        }
       }
     }
   } else {
@@ -1103,7 +1176,8 @@ void NativeAnimatedNodesManager::onRender() {
         }
       }
 
-      // Step 2: update all nodes that are connected to the finished animations.
+      // Step 2: update all nodes that are connected to the finished
+      // animations.
       updateNodes(finishedAnimationValueNodes);
 
       isEventAnimationInProgress_ = false;

package/ReactCommon/react/renderer/animated/NativeAnimatedNodesManager.h

@@ -21,6 +21,7 @@
 #include <react/renderer/animationbackend/AnimationBackend.h>
 #endif
 #include <react/renderer/core/ReactPrimitives.h>
+#include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/uimanager/UIManagerAnimationBackend.h>
 #include <chrono>
 #include <memory>
@@ -101,6 +102,8 @@ class NativeAnimatedNodesManager {
 
   void connectAnimatedNodeToView(Tag propsNodeTag, Tag viewTag) noexcept;
 
+  void connectAnimatedNodeToShadowNodeFamily(Tag propsNodeTag, std::shared_ptr<const ShadowNodeFamily> family) noexcept;
+
   void disconnectAnimatedNodes(Tag parentTag, Tag childTag) noexcept;
 
   void disconnectAnimatedNodeFromView(Tag propsNodeTag, Tag viewTag) noexcept;
@@ -258,6 +261,9 @@ class NativeAnimatedNodesManager {
   std::unordered_map<Tag, folly::dynamic> updateViewProps_{};
   std::unordered_map<Tag, folly::dynamic> updateViewPropsDirect_{};
 
+  mutable std::mutex tagToShadowNodeFamilyMutex_;
+  std::unordered_map<Tag, std::weak_ptr<const ShadowNodeFamily>> tagToShadowNodeFamily_{};
+
   /*
    * Sometimes a view is not longer connected to a PropsAnimatedNode, but
    * NativeAnimated has previously changed the view's props via direct

package/ReactCommon/react/renderer/animated/drivers/FrameAnimationDriver.cpp

@@ -43,6 +43,7 @@ void FrameAnimationDriver::updateConfig(folly::dynamic config) {
 void FrameAnimationDriver::onConfigChanged() {
   auto frames = config_["frames"];
   react_native_assert(frames.type() == folly::dynamic::ARRAY);
+  frames_.clear();
   for (const auto& frame : frames) {
     auto frameValue = frame.asDouble();
     frames_.push_back(frameValue);

package/ReactCommon/react/renderer/animated/nodes/ColorAnimatedNode.cpp

@@ -62,7 +62,6 @@ Color ColorAnimatedNode::getColor() {
     manager_->updatedNodeTags_.erase(tag_);
   }
   return color_;
-  return 0;
 }
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/animated/nodes/PropsAnimatedNode.h

@@ -14,6 +14,7 @@
 #include "AnimatedNode.h"
 
 #include <react/renderer/animated/internal/primitives.h>
+#include <react/renderer/core/ShadowNode.h>
 #include <mutex>
 
 namespace facebook::react {

package/ReactCommon/react/renderer/animated/nodes/RoundAnimatedNode.cpp

@@ -22,7 +22,7 @@ RoundAnimatedNode::RoundAnimatedNode(
     NativeAnimatedNodesManager& manager)
     : ValueAnimatedNode(tag, config, manager),
       inputNodeTag_(static_cast<Tag>(getConfig()["input"].asInt())),
-      nearest_(getConfig()["input"].asDouble()) {
+      nearest_(getConfig()["nearest"].asDouble()) {
   react_native_assert(
       nearest_ != 0 &&
       "'nearest' cannot be 0 (can't round to the nearest multiple of 0)");

package/ReactCommon/react/renderer/animated/nodes/ValueAnimatedNode.cpp

@@ -55,7 +55,7 @@ bool ValueAnimatedNode::setOffset(double offset) noexcept {
     offset_ = offset;
     return true;
   }
-  return true;
+  return false;
 }
 
 double ValueAnimatedNode::getValue() const noexcept {

package/ReactCommon/react/renderer/animated/tests/AnimatedNodeTests.cpp

@@ -215,6 +215,73 @@ TEST_F(AnimatedNodeTests, DiffClampAnimatedNode) {
   EXPECT_EQ(nodesManager_->getValue(diffClampTag), 1);
 }
 
+TEST_F(AnimatedNodeTests, RoundAnimatedNodeUsesNearestConfigKey) {
+  // This test verifies that RoundAnimatedNode reads the "nearest" config key
+  // for the rounding factor, not the "input" key.
+  initNodesManager();
+
+  auto rootTag = getNextRootViewTag();
+
+  auto valueTag = ++rootTag;
+  auto roundTag = ++rootTag;
+
+  nodesManager_->createAnimatedNode(
+      valueTag,
+      folly::dynamic::object("type", "value")("value", 7.3)("offset", 0));
+
+  // The round node should read "nearest" for the rounding factor (5.0),
+  // not "input" (which is the valueTag integer).
+  nodesManager_->createAnimatedNode(
+      roundTag,
+      folly::dynamic::object("type", "round")("input", valueTag)(
+          "nearest", 5.0));
+  nodesManager_->connectAnimatedNodes(valueTag, roundTag);
+
+  runAnimationFrame(0);
+
+  // 7.3 rounded to nearest 5.0 should be 5.0 (since round(7.3/5) * 5 = 1 * 5)
+  // If the bug existed (reading "input" instead of "nearest"), it would use
+  // the valueTag as the rounding factor, giving incorrect results.
+  EXPECT_DOUBLE_EQ(nodesManager_->getValue(roundTag).value(), 5.0);
+
+  // Test another value to ensure rounding works correctly
+  nodesManager_->setAnimatedNodeValue(valueTag, 12.6);
+  runAnimationFrame(0);
+
+  // 12.6 rounded to nearest 5.0 should be 15.0 (since round(12.6/5) * 5 = 3 *
+  // 5)
+  EXPECT_DOUBLE_EQ(nodesManager_->getValue(roundTag).value(), 15.0);
+}
+
+TEST_F(AnimatedNodeTests, SetOffsetReturnsFalseWhenUnchanged) {
+  // This test verifies that setAnimatedNodeOffset doesn't trigger unnecessary
+  // updates when the offset value hasn't changed.
+  initNodesManager();
+
+  auto rootTag = getNextRootViewTag();
+  auto valueTag = ++rootTag;
+
+  nodesManager_->createAnimatedNode(
+      valueTag,
+      folly::dynamic::object("type", "value")("value", 10)("offset", 0));
+
+  runAnimationFrame(0);
+  EXPECT_EQ(nodeNeedsUpdate(valueTag), false);
+
+  // First setOffset should mark the node as needing update
+  nodesManager_->setAnimatedNodeOffset(valueTag, 5);
+  EXPECT_EQ(nodeNeedsUpdate(valueTag), true);
+  EXPECT_EQ(nodesManager_->getValue(valueTag), 15); // 10 + 5
+
+  runAnimationFrame(0);
+  EXPECT_EQ(nodeNeedsUpdate(valueTag), false);
+
+  // Setting the same offset again should NOT mark the node as needing update
+  nodesManager_->setAnimatedNodeOffset(valueTag, 5);
+  EXPECT_EQ(nodeNeedsUpdate(valueTag), false); // No change, no update needed
+  EXPECT_EQ(nodesManager_->getValue(valueTag), 15); // Still 10 + 5
+}
+
 TEST_F(AnimatedNodeTests, ObjectAnimatedNode) {
   initNodesManager();
 

package/ReactCommon/react/renderer/animated/tests/AnimationDriverTests.cpp

@@ -58,4 +58,63 @@ TEST_F(AnimationDriverTests, framesAnimation) {
   EXPECT_EQ(round(nodesManager_->getValue(valueNodeTag).value()), toValue);
 }
 
+TEST_F(AnimationDriverTests, framesAnimationReconfigurationClearsFrames) {
+  // This test verifies that when an animation is reconfigured via updateConfig,
+  // the frames array is cleared before adding new frames. Without clearing,
+  // frames would accumulate and cause incorrect animation behavior.
+  initNodesManager();
+
+  auto rootTag = getNextRootViewTag();
+
+  auto valueNodeTag = ++rootTag;
+  nodesManager_->createAnimatedNode(
+      valueNodeTag,
+      folly::dynamic::object("type", "value")("value", 0)("offset", 0));
+
+  const auto animationId = 1;
+  // First animation: 5 frames from 0 to 100
+  const auto frames1 = folly::dynamic::array(0.0f, 0.25f, 0.5f, 0.75f, 1.0f);
+  const auto toValue1 = 100;
+  nodesManager_->startAnimatingNode(
+      animationId,
+      valueNodeTag,
+      folly::dynamic::object("type", "frames")("frames", frames1)(
+          "toValue", toValue1),
+      std::nullopt);
+
+  const double startTimeInTick = 12345;
+
+  // Run first frame
+  runAnimationFrame(startTimeInTick);
+  EXPECT_EQ(round(nodesManager_->getValue(valueNodeTag).value()), 0);
+
+  // Reconfigure the same animation (same animationId) with new frames
+  // This triggers updateConfig on the existing FrameAnimationDriver
+  const auto frames2 = folly::dynamic::array(0.0f, 0.5f, 1.0f);
+  const auto toValue2 = 200;
+  nodesManager_->startAnimatingNode(
+      animationId,
+      valueNodeTag,
+      folly::dynamic::object("type", "frames")("frames", frames2)(
+          "toValue", toValue2),
+      std::nullopt);
+
+  // Reset animation timing
+  const double newStartTimeInTick = 20000;
+
+  // Run animation at halfway point (1 frame into 3-frame animation)
+  runAnimationFrame(newStartTimeInTick);
+  runAnimationFrame(newStartTimeInTick + SingleFrameIntervalMs * 1);
+
+  // At frame 1 of 3 frames (50% progress), value should be approximately:
+  // startValue (0) + 0.5 * (toValue2 - startValue) = 0 + 0.5 * 200 = 100
+  // If frames accumulated (5 + 3 = 8 frames), we'd be at wrong position
+  // Use ceil rounding so 100.00x becomes 100.01
+  EXPECT_EQ(round(nodesManager_->getValue(valueNodeTag).value()), 100.01);
+
+  // Complete the animation
+  runAnimationFrame(newStartTimeInTick + SingleFrameIntervalMs * 2);
+  EXPECT_EQ(round(nodesManager_->getValue(valueNodeTag).value()), toValue2);
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/animationbackend/AnimatedPropsRegistry.cpp

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "AnimatedPropsRegistry.h"
+#include <react/renderer/core/PropsParserContext.h>
+#include "AnimatedProps.h"
+
+namespace facebook::react {
+
+void AnimatedPropsRegistry::update(
+    const std::unordered_map<SurfaceId, SurfaceUpdates>& surfaceUpdates) {
+  auto lock = std::lock_guard(mutex_);
+  for (const auto& [surfaceId, updates] : surfaceUpdates) {
+    auto& surfaceContext = surfaceContexts_[surfaceId];
+    auto& pendingMap = surfaceContext.pendingMap;
+    auto& pendingFamilies = surfaceContext.pendingFamilies;
+
+    auto& updatesMap = updates.propsMap;
+    auto& updatesFamilies = updates.families;
+
+    for (auto& family : updatesFamilies) {
+      pendingFamilies.insert(family);
+    }
+
+    for (auto& [tag, animatedProps] : updatesMap) {
+      auto it = pendingMap.find(tag);
+      if (it == pendingMap.end()) {
+        it = pendingMap.insert_or_assign(tag, std::make_unique<PropsSnapshot>())
+                 .first;
+      }
+      auto& snapshot = it->second;
+      auto& viewProps = snapshot->props;
+
+      for (const auto& animatedProp : animatedProps.props) {
+        snapshot->propNames.insert(animatedProp->propName);
+        cloneProp(viewProps, *animatedProp);
+      }
+    }
+  }
+}
+
+std::pair<std::unordered_set<const ShadowNodeFamily*>&, SnapshotMap&>
+AnimatedPropsRegistry::getMap(SurfaceId surfaceId) {
+  auto lock = std::lock_guard(mutex_);
+  auto& [pendingMap, map, pendingFamilies, families] =
+      surfaceContexts_[surfaceId];
+
+  for (auto& family : pendingFamilies) {
+    families.insert(family);
+  }
+  for (auto& [tag, propsSnapshot] : pendingMap) {
+    auto currentIt = map.find(tag);
+    if (currentIt == map.end()) {
+      map.insert_or_assign(tag, std::move(propsSnapshot));
+    } else {
+      auto& currentSnapshot = currentIt->second;
+      for (auto& propName : propsSnapshot->propNames) {
+        currentSnapshot->propNames.insert(propName);
+        updateProp(propName, currentSnapshot->props, *propsSnapshot);
+      }
+    }
+  }
+  pendingMap.clear();
+  pendingFamilies.clear();
+
+  return {families, map};
+}
+
+void AnimatedPropsRegistry::clear(SurfaceId surfaceId) {
+  auto lock = std::lock_guard(mutex_);
+
+  auto& surfaceContext = surfaceContexts_[surfaceId];
+  surfaceContext.families.clear();
+  surfaceContext.map.clear();
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/animationbackend/AnimatedPropsRegistry.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <folly/dynamic.h>
+#include <react/renderer/components/view/BaseViewProps.h>
+#include <react/renderer/core/ReactPrimitives.h>
+#include <react/renderer/uimanager/UIManager.h>
+#include <react/renderer/uimanager/UIManagerCommitHook.h>
+#include "AnimatedProps.h"
+
+namespace facebook::react {
+
+struct PropsSnapshot {
+  BaseViewProps props;
+  std::unordered_set<PropName> propNames;
+};
+
+struct SurfaceContext {
+  std::unordered_map<Tag, std::unique_ptr<PropsSnapshot>> pendingMap, map;
+  std::unordered_set<const ShadowNodeFamily *> pendingFamilies, families;
+};
+
+struct SurfaceUpdates {
+  std::unordered_set<const ShadowNodeFamily *> families;
+  std::unordered_map<Tag, AnimatedProps> propsMap;
+};
+
+using SnapshotMap = std::unordered_map<Tag, std::unique_ptr<PropsSnapshot>>;
+
+class AnimatedPropsRegistry {
+ public:
+  void update(const std::unordered_map<SurfaceId, SurfaceUpdates> &surfaceUpdates);
+  void clear(SurfaceId surfaceId);
+  std::pair<std::unordered_set<const ShadowNodeFamily *> &, SnapshotMap &> getMap(SurfaceId surfaceId);
+
+ private:
+  std::unordered_map<SurfaceId, SurfaceContext> surfaceContexts_;
+  std::mutex mutex_;
+};
+
+inline void updateProp(const PropName propName, BaseViewProps &viewProps, const PropsSnapshot &snapshot)
+{
+  switch (propName) {
+    case OPACITY:
+      viewProps.opacity = snapshot.props.opacity;
+      break;
+
+    case WIDTH:
+      viewProps.yogaStyle.setDimension(
+          yoga::Dimension::Width, snapshot.props.yogaStyle.dimension(yoga::Dimension::Width));
+      break;
+
+    case HEIGHT: {
+      auto d = snapshot.props.yogaStyle.dimension(yoga::Dimension::Height);
+      viewProps.yogaStyle.setDimension(yoga::Dimension::Height, d);
+      break;
+    }
+
+    case TRANSFORM:
+      viewProps.transform = snapshot.props.transform;
+      break;
+
+    case BORDER_RADII:
+      viewProps.borderRadii = snapshot.props.borderRadii;
+      break;
+
+    case FLEX:
+      viewProps.yogaStyle.setFlex(snapshot.props.yogaStyle.flex());
+      break;
+
+    case BACKGROUND_COLOR:
+      viewProps.backgroundColor = snapshot.props.backgroundColor;
+      break;
+  }
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/animationbackend/AnimationBackend.cpp

@@ -9,6 +9,7 @@
 #include <react/renderer/animationbackend/AnimatedPropsSerializer.h>
 #include <react/renderer/graphics/Color.h>
 #include <chrono>
+#include "AnimatedPropsRegistry.h"
 
 namespace facebook::react {
 
@@ -70,12 +71,14 @@ AnimationBackend::AnimationBackend(
       stopOnRenderCallback_(std::move(stopOnRenderCallback)),
       directManipulationCallback_(std::move(directManipulationCallback)),
       fabricCommitCallback_(std::move(fabricCommitCallback)),
-      uiManager_(uiManager) {}
+      animatedPropsRegistry_(std::make_shared<AnimatedPropsRegistry>()),
+      uiManager_(uiManager),
+      commitHook_(uiManager, animatedPropsRegistry_) {}
 
 void AnimationBackend::onAnimationFrame(double timestamp) {
-  std::unordered_map<Tag, AnimatedProps> updates;
-  std::unordered_map<SurfaceId, std::unordered_set<const ShadowNodeFamily*>>
-      surfaceToFamilies;
+  std::unordered_map<Tag, AnimatedProps> synchronousUpdates;
+  std::unordered_map<SurfaceId, SurfaceUpdates> surfaceUpdates;
+
   bool hasAnyLayoutUpdates = false;
   for (auto& callback : callbacks) {
     auto muatations = callback(static_cast<float>(timestamp));
@@ -83,22 +86,28 @@ void AnimationBackend::onAnimationFrame(double timestamp) {
       hasAnyLayoutUpdates |= mutationHasLayoutUpdates(mutation);
       const auto family = mutation.family;
       if (family != nullptr) {
-        surfaceToFamilies[family->getSurfaceId()].insert(family);
+        auto& [families, updates] = surfaceUpdates[family->getSurfaceId()];
+        families.insert(family.get());
+        updates[mutation.tag] = std::move(mutation.props);
+      } else {
+        synchronousUpdates[mutation.tag] = std::move(mutation.props);
       }
-      updates[mutation.tag] = std::move(mutation.props);
     }
   }
 
+  animatedPropsRegistry_->update(surfaceUpdates);
+
   if (hasAnyLayoutUpdates) {
-    commitUpdates(surfaceToFamilies, updates);
+    commitUpdates(surfaceUpdates);
   } else {
-    synchronouslyUpdateProps(updates);
+    synchronouslyUpdateProps(synchronousUpdates);
   }
 }
 
 void AnimationBackend::start(const Callback& callback, bool isAsync) {
   callbacks.push_back(callback);
-  // TODO: startOnRenderCallback_ should provide the timestamp from the platform
+  // TODO: startOnRenderCallback_ should provide the timestamp from the
+  // platform
   if (startOnRenderCallback_) {
     startOnRenderCallback_(
         [this]() {
@@ -117,13 +126,11 @@ void AnimationBackend::stop(bool isAsync) {
 }
 
 void AnimationBackend::commitUpdates(
-    const std::unordered_map<
-        SurfaceId,
-        std::unordered_set<const ShadowNodeFamily*>>& surfaceToFamilies,
-    std::unordered_map<Tag, AnimatedProps>& updates) {
-  for (const auto& surfaceEntry : surfaceToFamilies) {
+    std::unordered_map<SurfaceId, SurfaceUpdates>& surfaceUpdates) {
+  for (auto& surfaceEntry : surfaceUpdates) {
     const auto& surfaceId = surfaceEntry.first;
-    const auto& surfaceFamilies = surfaceEntry.second;
+    const auto& surfaceFamilies = surfaceEntry.second.families;
+    auto& updates = surfaceEntry.second.propsMap;
     uiManager_->getShadowTreeRegistry().visit(
         surfaceId, [&surfaceFamilies, &updates](const ShadowTree& shadowTree) {
           shadowTree.commit(
@@ -165,4 +172,8 @@ void AnimationBackend::synchronouslyUpdateProps(
   }
 }
 
+void AnimationBackend::clearRegistry(SurfaceId surfaceId) {
+  animatedPropsRegistry_->clear(surfaceId);
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/animationbackend/AnimationBackend.h

@@ -15,6 +15,8 @@
 #include <vector>
 #include "AnimatedProps.h"
 #include "AnimatedPropsBuilder.h"
+#include "AnimatedPropsRegistry.h"
+#include "AnimationBackendCommitHook.h"
 
 namespace facebook::react {
 
@@ -32,7 +34,7 @@ class UIManagerNativeAnimatedDelegateBackendImpl : public UIManagerNativeAnimate
 
 struct AnimationMutation {
   Tag tag;
-  const ShadowNodeFamily *family;
+  std::shared_ptr<const ShadowNodeFamily> family;
   AnimatedProps props;
 };
 
@@ -51,7 +53,9 @@ class AnimationBackend : public UIManagerAnimationBackend {
   const StopOnRenderCallback stopOnRenderCallback_;
   const DirectManipulationCallback directManipulationCallback_;
   const FabricCommitCallback fabricCommitCallback_;
+  std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry_;
   UIManager *uiManager_;
+  AnimationBackendCommitHook commitHook_;
 
   AnimationBackend(
       StartOnRenderCallback &&startOnRenderCallback,
@@ -59,10 +63,9 @@ class AnimationBackend : public UIManagerAnimationBackend {
       DirectManipulationCallback &&directManipulationCallback,
       FabricCommitCallback &&fabricCommitCallback,
       UIManager *uiManager);
-  void commitUpdates(
-      const std::unordered_map<SurfaceId, std::unordered_set<const ShadowNodeFamily *>> &surfaceToFamilies,
-      std::unordered_map<Tag, AnimatedProps> &updates);
+  void commitUpdates(std::unordered_map<SurfaceId, SurfaceUpdates> &surfaceUpdates);
   void synchronouslyUpdateProps(const std::unordered_map<Tag, AnimatedProps> &updates);
+  void clearRegistry(SurfaceId surfaceId) override;
 
   void onAnimationFrame(double timestamp) override;
   void start(const Callback &callback, bool isAsync);