@react-native-ohos/react-native-reanimated 3.18.1-rc.6 → 4.0.0-rc.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedCommitHook.h

@@ -1,8 +1,7 @@
 #pragma once
-#ifdef RCT_NEW_ARCH_ENABLED
 
-#include <reanimated/Fabric/PropsRegistry.h>
-#include <reanimated/LayoutAnimations/LayoutAnimationsProxy.h>
+#include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.h>
 
 #include <react/renderer/uimanager/UIManagerCommitHook.h>
 
@@ -12,14 +11,12 @@ using namespace facebook::react;
 
 namespace reanimated {
 
-class ReanimatedCommitHook
-    : public UIManagerCommitHook,
-      public std::enable_shared_from_this<ReanimatedCommitHook> {
+class ReanimatedCommitHook : public UIManagerCommitHook, public std::enable_shared_from_this<ReanimatedCommitHook> {
  public:
   ReanimatedCommitHook(
-      const std::shared_ptr<PropsRegistry> &propsRegistry,
       const std::shared_ptr<UIManager> &uiManager,
-      const std::shared_ptr<LayoutAnimationsProxy> &layoutAnimationsProxy);
+      const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
+      const std::shared_ptr<LayoutAnimationsProxyCommon> &layoutAnimationsProxy);
 
   ~ReanimatedCommitHook() noexcept override;
 
@@ -32,14 +29,17 @@ 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_;
-
   std::shared_ptr<UIManager> uiManager_;
-
-  std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy_;
+  std::shared_ptr<UpdatesRegistryManager> updatesRegistryManager_;
+  std::shared_ptr<LayoutAnimationsProxyCommon> layoutAnimationsProxy_;
 
   SurfaceId currentMaxSurfaceId_ = -1;
 
@@ -47,5 +47,3 @@ class ReanimatedCommitHook
 };
 
 } // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedCommitShadowNode.h

@@ -1,5 +1,4 @@
 #pragma once
-#ifdef RCT_NEW_ARCH_ENABLED
 
 #include <react/renderer/core/ShadowNode.h>
 
@@ -45,5 +44,3 @@ class ReanimatedCommitShadowNode : public ShadowNode {
 };
 
 } // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedMountHook.cpp

@@ -1,14 +1,16 @@
-#ifdef RCT_NEW_ARCH_ENABLED
-
 #include <reanimated/Fabric/ReanimatedCommitShadowNode.h>
 #include <reanimated/Fabric/ReanimatedMountHook.h>
+#include <reanimated/Tools/ReanimatedSystraceSection.h>
+
+#include <memory>
 
 namespace reanimated {
 
 ReanimatedMountHook::ReanimatedMountHook(
-    const std::shared_ptr<PropsRegistry> &propsRegistry,
-    const std::shared_ptr<UIManager> &uiManager)
-    : propsRegistry_(propsRegistry), uiManager_(uiManager) {
+    const std::shared_ptr<UIManager> &uiManager,
+    const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
+    const std::function<void()> &requestFlush)
+    : uiManager_(uiManager), updatesRegistryManager_(updatesRegistryManager), requestFlush_(requestFlush) {
   uiManager_->registerMountHook(*this);
 }
 
@@ -18,10 +20,16 @@ ReanimatedMountHook::~ReanimatedMountHook() noexcept {
 
 void ReanimatedMountHook::shadowTreeDidMount(
     const RootShadowNode::Shared &rootShadowNode,
-    double) noexcept {
-  auto reaShadowNode =
-      std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(
-          std::const_pointer_cast<RootShadowNode>(rootShadowNode));
+#if REACT_NATIVE_MINOR_VERSION >= 81
+    HighResTimeStamp
+#else
+    double
+#endif // REACT_NATIVE_MINOR_VERSION >= 81
+    ) noexcept {
+  ReanimatedSystraceSection s("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
@@ -33,55 +41,16 @@ void ReanimatedMountHook::shadowTreeDidMount(
   }
 
   {
-    auto lock = propsRegistry_->createLock();
-    propsRegistry_->handleNodeRemovals(*rootShadowNode);
+    auto lock = updatesRegistryManager_->lock();
+    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
-    propsRegistry_->unpauseReanimatedCommits();
-    if (!propsRegistry_->shouldCommitAfterPause()) {
-      return;
+    updatesRegistryManager_->unpauseReanimatedCommits();
+    if (updatesRegistryManager_->shouldCommitAfterPause()) {
+      requestFlush_();
     }
   }
-
-  const auto &shadowTreeRegistry = uiManager_->getShadowTreeRegistry();
-  shadowTreeRegistry.visit(
-      rootShadowNode->getSurfaceId(), [&](ShadowTree const &shadowTree) {
-        shadowTree.commit(
-            [&](RootShadowNode const &oldRootShadowNode)
-                -> RootShadowNode::Unshared {
-              PropsMap propsMap;
-
-              RootShadowNode::Unshared rootNode =
-                  std::static_pointer_cast<RootShadowNode>(
-                      oldRootShadowNode.ShadowNode::clone({}));
-              {
-                auto lock = propsRegistry_->createLock();
-
-                propsRegistry_->for_each([&](const ShadowNodeFamily &family,
-                                             const folly::dynamic &props) {
-                  propsMap[&family].emplace_back(props);
-                });
-
-                rootNode =
-                    cloneShadowTreeWithNewProps(oldRootShadowNode, propsMap);
-              }
-
-              // Mark the commit as Reanimated commit so that we can
-              // distinguish it in ReanimatedCommitHook.
-              auto reaShadowNode =
-                  std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(
-                      rootNode);
-              reaShadowNode->setReanimatedCommitTrait();
-
-              return rootNode;
-            },
-            {/* .enableStateReconciliation = */
-             false,
-             /* .mountSynchronously = */ true});
-      });
 }
 
 } // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ReanimatedMountHook.h

@@ -1,8 +1,7 @@
 #pragma once
-#ifdef RCT_NEW_ARCH_ENABLED
 
-#include <reanimated/Fabric/PropsRegistry.h>
 #include <reanimated/Fabric/ShadowTreeCloner.h>
+#include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
 
 #include <react/renderer/uimanager/UIManagerMountHook.h>
 
@@ -15,19 +14,24 @@ using namespace facebook::react;
 class ReanimatedMountHook : public UIManagerMountHook {
  public:
   ReanimatedMountHook(
-      const std::shared_ptr<PropsRegistry> &propsRegistry,
-      const std::shared_ptr<UIManager> &uiManager);
+      const std::shared_ptr<UIManager> &uiManager,
+      const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
+      const std::function<void()> &requestFlush);
   ~ReanimatedMountHook() noexcept override;
 
   void shadowTreeDidMount(
       RootShadowNode::Shared const &rootShadowNode,
-      double mountTime) noexcept override;
+#if REACT_NATIVE_MINOR_VERSION >= 81
+      HighResTimeStamp mountTime
+#else
+      double mountTime
+#endif // REACT_NATIVE_MINOR_VERSION >= 81
+      ) noexcept override;
 
  private:
-  const std::shared_ptr<PropsRegistry> propsRegistry_;
   const std::shared_ptr<UIManager> uiManager_;
+  const std::shared_ptr<UpdatesRegistryManager> updatesRegistryManager_;
+  const std::function<void()> requestFlush_;
 };
 
 } // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ShadowTreeCloner.cpp

@@ -1,24 +1,22 @@
-#ifdef RCT_NEW_ARCH_ENABLED
-
 #include <reanimated/Fabric/ShadowTreeCloner.h>
+#include <reanimated/Tools/ReanimatedSystraceSection.h>
 
+#include <memory>
 #include <ranges>
 #include <utility>
 
 namespace reanimated {
 
-Props::Shared mergeProps(
-    const ShadowNode &shadowNode,
-    const PropsMap &propsMap,
-    const ShadowNodeFamily &family) {
+Props::Shared mergeProps(const ShadowNode &shadowNode, const PropsMap &propsMap, const ShadowNodeFamily &family) {
+  ReanimatedSystraceSection s("ShadowTreeCloner::mergeProps");
+
   const auto it = propsMap.find(&family);
 
   if (it == propsMap.end()) {
     return ShadowNodeFragment::propsPlaceholder();
   }
 
-  PropsParserContext propsParserContext{
-      shadowNode.getSurfaceId(), *shadowNode.getContextContainer()};
+  PropsParserContext propsParserContext{shadowNode.getSurfaceId(), *shadowNode.getContextContainer()};
   const auto &propsVector = it->second;
   auto newProps = shadowNode.getProps();
 
@@ -26,23 +24,20 @@ Props::Shared mergeProps(
   if (propsVector.size() > 1) {
     folly::dynamic newPropsDynamic = folly::dynamic::object;
     for (const auto &props : propsVector) {
-      newPropsDynamic = folly::dynamic::merge(
-          props.operator folly::dynamic(), newPropsDynamic);
+      newPropsDynamic = folly::dynamic::merge(props.operator folly::dynamic(), newPropsDynamic);
     }
-    return shadowNode.getComponentDescriptor().cloneProps(
-        propsParserContext, newProps, RawProps(newPropsDynamic));
+    return shadowNode.getComponentDescriptor().cloneProps(propsParserContext, newProps, RawProps(newPropsDynamic));
   }
 #endif
 
   for (const auto &props : propsVector) {
-    newProps = shadowNode.getComponentDescriptor().cloneProps(
-        propsParserContext, newProps, RawProps(props));
+    newProps = shadowNode.getComponentDescriptor().cloneProps(propsParserContext, newProps, RawProps(props));
   }
 
   return newProps;
 }
 
-ShadowNode::Unshared cloneShadowTreeWithNewPropsRecursive(
+std::shared_ptr<ShadowNode> cloneShadowTreeWithNewPropsRecursive(
     const ShadowNode &shadowNode,
     const ChildrenMap &childrenMap,
     const PropsMap &propsMap) {
@@ -52,35 +47,51 @@ ShadowNode::Unshared cloneShadowTreeWithNewPropsRecursive(
 
   if (affectedChildrenIt != childrenMap.end()) {
     for (const auto index : affectedChildrenIt->second) {
-      children[index] = cloneShadowTreeWithNewPropsRecursive(
-          *children[index], childrenMap, propsMap);
+      children[index] = cloneShadowTreeWithNewPropsRecursive(*children[index], childrenMap, propsMap);
     }
   }
 
   return shadowNode.clone(
       {mergeProps(shadowNode, propsMap, *family),
-       std::make_shared<ShadowNode::ListOfShared>(children),
-       shadowNode.getState()});
+       std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>(children),
+       shadowNode.getState(),
+       false});
 }
 
-RootShadowNode::Unshared cloneShadowTreeWithNewProps(
-    const RootShadowNode &oldRootNode,
-    const PropsMap &propsMap) {
-  ChildrenMap childrenMap;
+RootShadowNode::Unshared cloneShadowTreeWithNewProps(const RootShadowNode &oldRootNode, const PropsMap &propsMap) {
+  ReanimatedSystraceSection s("ShadowTreeCloner::cloneShadowTreeWithNewProps");
 
-  for (auto &[family, _] : propsMap) {
-    const auto ancestors = family->getAncestors(oldRootNode);
-
-    for (const auto &[parentNode, index] :
-         std::ranges::reverse_view(ancestors)) {
-      const auto parentFamily = &parentNode.get().getFamily();
-      auto &affectedChildren = childrenMap[parentFamily];
-
-      if (affectedChildren.contains(index)) {
-        continue;
-      }
+  ChildrenMap childrenMap;
 
-      affectedChildren.insert(index);
+  {
+    ReanimatedSystraceSection s("ShadowTreeCloner::prepareChildrenMap");
+
+    for (auto &[family, _] : propsMap) {
+      const auto ancestors = family->getAncestors(oldRootNode);
+
+//      for (const auto &[parentNode, index] : std::ranges::reverse_view(ancestors)) {
+//        const auto parentFamily = &parentNode.get().getFamily();
+//        auto &affectedChildren = childrenMap[parentFamily];
+//
+//        if (affectedChildren.contains(index)) {
+//          continue;
+//        }
+//
+//        affectedChildren.insert(index);
+//      }
+       //TODO     
+       for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
+          const auto &[parentNode, index] = *it;
+          
+          const auto parentFamily = &parentNode.get().getFamily();
+          auto &affectedChildren = childrenMap[parentFamily];
+        
+          if (affectedChildren.find(index) != affectedChildren.end()) {
+            continue;
+          }
+        
+          affectedChildren.insert(index);
+       }          
     }
   }
 
@@ -91,5 +102,3 @@ RootShadowNode::Unshared cloneShadowTreeWithNewProps(
 }
 
 } // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ShadowTreeCloner.h

@@ -1,5 +1,4 @@
 #pragma once
-#ifdef RCT_NEW_ARCH_ENABLED
 
 #include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/uimanager/UIManager.h>
@@ -15,15 +14,9 @@ using namespace react;
 
 namespace reanimated {
 
-using PropsMap =
-    std::unordered_map<const ShadowNodeFamily *, std::vector<RawProps>>;
-using ChildrenMap =
-    std::unordered_map<const ShadowNodeFamily *, std::unordered_set<int>>;
+using PropsMap = std::unordered_map<const ShadowNodeFamily *, std::vector<RawProps>>;
+using ChildrenMap = std::unordered_map<const ShadowNodeFamily *, std::unordered_set<int>>;
 
-RootShadowNode::Unshared cloneShadowTreeWithNewProps(
-    const RootShadowNode &oldRootNode,
-    const PropsMap &propsMap);
+RootShadowNode::Unshared cloneShadowTreeWithNewProps(const RootShadowNode &oldRootNode, const PropsMap &propsMap);
 
 } // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/AnimatedPropsRegistry.cpp

@@ -0,0 +1,72 @@
+#include <reanimated/Fabric/updates/AnimatedPropsRegistry.h>
+#include <reanimated/Tools/FeatureFlags.h>
+
+#include <memory>
+#include <utility>
+
+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
+
+void AnimatedPropsRegistry::update(jsi::Runtime &rt, const jsi::Value &operations, const double timestamp) {
+  auto operationsArray = operations.asObject(rt).asArray(rt);
+
+  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");
+    auto shadowNode = shadowNodeFromValue(rt, shadowNodeWrapper);
+
+    const jsi::Value &updates = item.getProperty(rt, "updates");
+    addUpdatesToBatch(shadowNode, jsi::dynamicFromValue(rt, updates));
+
+    if constexpr (StaticFeatureFlags::getFlag("FORCE_REACT_RENDER_FOR_SETTLED_ANIMATIONS")) {
+      timestampMap_[shadowNode->getTag()] = timestamp;
+    }
+  }
+}
+
+void AnimatedPropsRegistry::remove(const Tag tag) {
+  updatesRegistry_.erase(tag);
+}
+
+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_) {
+    if (timestampMap_.at(viewTag) < timestamp) {
+      updates.emplace_back(viewTag, std::cref(pair.second));
+    }
+  }
+
+  const jsi::Array array(rt, updates.size());
+  size_t i = 0;
+  for (const auto &[viewTag, styleProps] : updates) {
+    const jsi::Object item(rt);
+    item.setProperty(rt, "viewTag", viewTag);
+    item.setProperty(rt, "styleProps", jsi::valueFromDynamic(rt, styleProps.get()));
+    array.setValueAtIndex(rt, i++, item);
+  }
+
+  return jsi::Value(rt, array);
+}
+
+void AnimatedPropsRegistry::removeUpdatesOlderThanTimestamp(const double timestamp) {
+  for (auto it = timestampMap_.begin(); it != timestampMap_.end();) {
+    const auto viewTag = it->first;
+    const auto viewTimestamp = it->second;
+    if (viewTimestamp < timestamp) {
+      it = timestampMap_.erase(it);
+      updatesRegistry_.erase(viewTag);
+    } else {
+      it++;
+    }
+  }
+}
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/AnimatedPropsRegistry.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <reanimated/Fabric/updates/UpdatesRegistry.h>
+
+#include <react/renderer/uimanager/UIManager.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+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);
+
+ private:
+  std::unordered_map<Tag, double> timestampMap_; // viewTag -> timestamp, protected by `mutex_`
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.cpp

@@ -0,0 +1,160 @@
+#include <reanimated/Fabric/updates/UpdatesRegistry.h>
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace reanimated {
+
+std::lock_guard<std::mutex> UpdatesRegistry::lock() const {
+  return std::lock_guard<std::mutex>{mutex_};
+}
+
+bool UpdatesRegistry::isEmpty() const {
+  return updatesRegistry_.empty();
+}
+
+folly::dynamic UpdatesRegistry::get(const Tag tag) const {
+  std::lock_guard<std::mutex> lock{mutex_};
+
+  auto it = updatesRegistry_.find(tag);
+  if (it == updatesRegistry_.cend()) {
+    return nullptr;
+  }
+  return it->second.second;
+}
+
+void UpdatesRegistry::flushUpdates(UpdatesBatch &updatesBatch) {
+  auto copiedUpdatesBatch = std::move(updatesBatch_);
+  updatesBatch_.clear();
+
+  // Store all updates in the registry for later use in the commit hook
+  flushUpdatesToRegistry(copiedUpdatesBatch);
+  // Flush the updates to the updatesBatch used to apply current changes
+  for (auto &[shadowNode, props] : copiedUpdatesBatch) {
+    updatesBatch.emplace_back(shadowNode, std::move(props));
+  }
+}
+
+void UpdatesRegistry::collectProps(PropsMap &propsMap) {
+  std::lock_guard<std::mutex> lock{mutex_};
+
+  auto copiedRegistry = updatesRegistry_;
+  for (const auto &[tag, pair] : copiedRegistry) {
+    const auto &[shadowNode, props] = pair;
+    auto &family = shadowNode->getFamily();
+    auto it = propsMap.find(&family);
+
+    if (it == propsMap.cend()) {
+      auto propsVector = std::vector<RawProps>{};
+      propsVector.emplace_back(RawProps(props));
+      propsMap.emplace(&family, propsVector);
+    } else {
+      it->second.push_back(RawProps(props));
+    }
+  }
+}
+
+void UpdatesRegistry::addUpdatesToBatch(
+    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const folly::dynamic &props) {
+  updatesBatch_.emplace_back(shadowNode, props);
+}
+
+void UpdatesRegistry::setInUpdatesRegistry(
+    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const folly::dynamic &props) {
+  const auto tag = shadowNode->getTag();
+#ifdef ANDROID
+  updatePropsToRevert(tag, &props);
+#endif
+  updatesRegistry_[tag] = std::make_pair(shadowNode, props);
+}
+
+folly::dynamic UpdatesRegistry::getUpdatesFromRegistry(const Tag tag) const {
+  auto it = updatesRegistry_.find(tag);
+  if (it == updatesRegistry_.cend()) {
+    return folly::dynamic();
+  }
+  return it->second.second;
+}
+
+void UpdatesRegistry::removeFromUpdatesRegistry(const Tag tag) {
+#ifdef ANDROID
+  updatePropsToRevert(tag);
+#endif
+  updatesRegistry_.erase(tag);
+}
+
+void UpdatesRegistry::flushUpdatesToRegistry(const UpdatesBatch &updatesBatch) {
+  for (auto &[shadowNode, props] : updatesBatch) {
+    const auto tag = shadowNode->getTag();
+    auto it = updatesRegistry_.find(tag);
+
+    if (it == updatesRegistry_.cend()) {
+      updatesRegistry_[tag] = std::make_pair(shadowNode, props);
+    } else {
+      it->second.second.update(props);
+    }
+  }
+}
+
+#ifdef ANDROID
+
+bool UpdatesRegistry::hasPropsToRevert() const {
+  return !propsToRevertMap_.empty();
+}
+
+void UpdatesRegistry::collectPropsToRevert(PropsToRevertMap &propsToRevertMap) {
+  std::lock_guard<std::mutex> lock{mutex_};
+
+  for (const auto &[tag, pair] : propsToRevertMap_) {
+    const auto &[shadowNode, props] = pair;
+    const auto it = propsToRevertMap.find(tag);
+    if (it == propsToRevertMap.end()) {
+      propsToRevertMap[tag] = {shadowNode, props};
+    } else {
+      it->second.props.insert(props.begin(), props.end());
+    }
+  }
+
+  propsToRevertMap_.clear();
+}
+
+void UpdatesRegistry::updatePropsToRevert(const Tag tag, const folly::dynamic *newProps) {
+  auto it = updatesRegistry_.find(tag);
+  if (it == updatesRegistry_.end()) {
+    return;
+  }
+
+  const auto &shadowNode = it->second.first;
+  const auto &registryProps = it->second.second;
+  if (propsToRevertMap_.find(tag) == propsToRevertMap_.end()) {
+    propsToRevertMap_[tag] = {shadowNode, std::unordered_set<std::string>()};
+  }
+
+  if (newProps == nullptr) {
+    // If newProps is not provided, revert all props from registry
+    for (const auto &propName : registryProps.keys()) {
+      propsToRevertMap_[tag].props.emplace(propName.asString());
+    }
+  } else {
+    // If newProps is provided, revert only props that are in registry but not
+    // in newProps
+    for (const auto &propName : registryProps.keys()) {
+      if (newProps->find(propName) == newProps->items().end()) {
+        propsToRevertMap_[tag].props.emplace(propName.asString());
+      }
+    }
+  }
+
+  if (propsToRevertMap_[tag].props.empty()) {
+    propsToRevertMap_.erase(tag);
+  }
+}
+
+#endif
+
+} // namespace reanimated