@react-native-ohos/react-native-reanimated 4.0.2 → 4.1.0-beta.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/registries/CSSAnimationsRegistry.h

@@ -2,12 +2,14 @@
 
 #include <reanimated/CSS/configs/CSSAnimationConfig.h>
 #include <reanimated/CSS/core/CSSAnimation.h>
-#include <reanimated/CSS/utils/DelayedItemsManager.h>
+#include <reanimated/CSS/core/CSSAnimationsGroup.h>
+#include <reanimated/CSS/core/CSSPlatformAnimationFactory.h>
+#include <reanimated/CSS/registries/CSSKeyframesRegistry.h>
 #include <reanimated/CSS/utils/props.h>
+#include <reanimated/Fabric/updates/OperationsLoop.h>
 #include <reanimated/Fabric/updates/UpdatesRegistry.h>
 
 #include <memory>
-#include <set>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
@@ -17,64 +19,61 @@
 namespace reanimated::css {
 
 using CSSAnimationsMap = std::unordered_map<size_t, std::shared_ptr<CSSAnimation>>;
-using CSSAnimationsVector = std::vector<std::shared_ptr<CSSAnimation>>;
 
-class CSSAnimationsRegistry : public UpdatesRegistry, std::enable_shared_from_this<CSSAnimationsRegistry> {
+class CSSAnimationsRegistry : public UpdatesRegistry {
  public:
-  using SettingsUpdates = std::vector<std::pair<size_t, PartialCSSAnimationSettings>>;
+  CSSAnimationsRegistry(
+      const std::shared_ptr<OperationsLoop> &loop,
+      const std::shared_ptr<CSSKeyframesRegistry> &keyframesRegistry,
+      const std::shared_ptr<CSSPlatformAnimationFactory> &platformAnimationFactory);
 
-  bool isEmpty() const override;
-  bool hasUpdates() const;
+  bool needsFlush() const;
 
   void apply(
-      jsi::Runtime &rt,
       const std::shared_ptr<const ShadowNode> &shadowNode,
-      const std::optional<std::vector<std::string>> &animationNames,
-      const CSSAnimationsMap &newAnimations,
-      const CSSAnimationSettingsUpdatesMap &settingsUpdates,
-      double timestamp);
-  void remove(Tag viewTag) override;
+      const std::string &compoundComponentName,
+      const CSSAnimationUpdates &updates);
 
-  void update(double timestamp);
+  void flushUpdates(UpdatesBatch &updatesBatch);
+#if REACT_NATIVE_VERSION_MINOR >= 85
+  void flushUpdates(UpdatesBatchAnimatedProps &updatesBatch);
+#endif
 
  private:
-  using AnimationToIndexMap = std::unordered_map<std::shared_ptr<CSSAnimation>, size_t>;
-  using RunningAnimationIndicesMap = std::unordered_map<Tag, std::set<size_t>>;
-  using AnimationsToRevertMap = std::unordered_map<Tag, std::unordered_set<size_t>>;
-  struct RegistryEntry {
-    const CSSAnimationsVector animationsVector;
-    const AnimationToIndexMap animationToIndexMap;
+  class AnimationObserver : public CSSAnimation::Observer {
+   public:
+    explicit AnimationObserver(CSSAnimationsRegistry &owner);
+    void onAnimationUpdate(Tag viewTag) override;
+    void onAnimationNeedsRevert(Tag viewTag) override;
+
+   private:
+    CSSAnimationsRegistry &owner_;
   };
 
-  using Registry = std::unordered_map<Tag, RegistryEntry>;
+  const std::shared_ptr<OperationsLoop> loop_;
+  const std::shared_ptr<CSSKeyframesRegistry> keyframesRegistry_;
+  const std::shared_ptr<CSSPlatformAnimationFactory> platformAnimationFactory_;
 
-  Registry registry_;
+  AnimationObserver animationObserver_{*this};
 
-  RunningAnimationIndicesMap runningAnimationIndicesMap_;
-  AnimationsToRevertMap animationsToRevertMap_;
-  DelayedItemsManager<std::shared_ptr<CSSAnimation>> delayedAnimationsManager_;
+  std::unordered_map<Tag, CSSAnimationsGroup> groups_;
+  // Tags reported by owned animations between flushes.
+  std::unordered_set<Tag> updatedTags_;
+  std::unordered_set<Tag> pendingRevertTags_;
 
-  CSSAnimationsVector buildAnimationsVector(
-      jsi::Runtime &rt,
+  void removeTag(Tag viewTag) override;
+  std::optional<CSSAnimationsGroup> maybeBuildNewGroup(
+      const std::shared_ptr<const ShadowNode> &shadowNode,
+      const std::string &compoundComponentName,
+      const std::optional<std::vector<std::string>> &updatedAnimationNames,
+      const CSSAnimationSettingsMap &newAnimationSettings);
+  std::shared_ptr<CSSAnimation> createAnimation(
       const std::shared_ptr<const ShadowNode> &shadowNode,
-      const std::optional<std::vector<std::string>> &animationNames,
-      const std::optional<CSSAnimationsMap> &newAnimations) const;
-  AnimationToIndexMap buildAnimationToIndexMap(const CSSAnimationsVector &animationsVector) const;
-  void updateAnimationSettings(
-      const CSSAnimationsVector &animationsVector,
-      const CSSAnimationSettingsUpdatesMap &settingsUpdates,
+      const std::string &name,
+      const std::string &compoundComponentName,
+      const CSSAnimationSettings &settings,
       double timestamp);
-
-  void
-  updateViewAnimations(Tag viewTag, const std::vector<size_t> &animationIndices, double timestamp, bool addToBatch);
-  void
-  scheduleOrActivateAnimation(size_t animationIndex, const std::shared_ptr<CSSAnimation> &animation, double timestamp);
-  void removeViewAnimations(Tag viewTag);
-  void applyViewAnimationsStyle(Tag viewTag, double timestamp);
-  void activateDelayedAnimations(double timestamp);
-  void handleAnimationsToRevert(double timestamp);
-
-  static bool addStyleUpdates(folly::dynamic &target, const folly::dynamic &updates, bool shouldOverride);
+  void updateRegistryForRevertedAnimations();
 };
 
 } // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/registries/CSSKeyframesRegistry.cpp

@@ -1,42 +1,42 @@
 #include <reanimated/CSS/registries/CSSKeyframesRegistry.h>
+#include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
+
+#include <react/debug/react_native_assert.h>
 
-#include <memory>
 #include <string>
 #include <utility>
 
 namespace reanimated::css {
 
-CSSKeyframesRegistry::CSSKeyframesRegistry(const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
-    : viewStylesRepository_(viewStylesRepository) {}
-
-const CSSKeyframesConfig &CSSKeyframesRegistry::get(
+std::optional<std::reference_wrapper<const CSSKeyframesConfig>> CSSKeyframesRegistry::get(
     const std::string &animationName,
-    const std::string &componentName) {
-  const auto &registryIt = registry_.find(animationName);
+    const std::string &compoundComponentName) {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+  const auto registryIt = registry_.find(animationName);
   if (registryIt == registry_.end()) {
-    throw std::runtime_error("[Reanimated] No keyframes with name `" + animationName + "` were registered");
+    return std::nullopt;
   }
 
-  const auto &keyframesByComponentName = registryIt->second;
-  const auto &keyframesByComponentNameIt = keyframesByComponentName.find(componentName);
-  if (keyframesByComponentNameIt == keyframesByComponentName.end()) {
-    throw std::runtime_error(
-        "[Reanimated] No keyframes with name `" + animationName + "` were registered for component `" + componentName +
-        "`");
+  const auto &keyframesByComponent = registryIt->second;
+  const auto keyframesByComponentIt = keyframesByComponent.find(compoundComponentName);
+  if (keyframesByComponentIt == keyframesByComponent.end()) {
+    return std::nullopt;
   }
 
-  return keyframesByComponentNameIt->second;
+  return std::cref(keyframesByComponentIt->second);
 }
 
 void CSSKeyframesRegistry::set(
     const std::string &animationName,
-    const std::string &componentName,
+    const std::string &compoundComponentName,
     CSSKeyframesConfig &&config) {
-  registry_[animationName][componentName] = std::move(config);
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+  registry_[animationName][compoundComponentName] = std::move(config);
 }
 
-void CSSKeyframesRegistry::remove(const std::string &animationName, const std::string &componentName) {
-  registry_[animationName].erase(componentName);
+void CSSKeyframesRegistry::remove(const std::string &animationName, const std::string &compoundComponentName) {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+  registry_[animationName].erase(compoundComponentName);
   if (registry_[animationName].empty()) {
     registry_.erase(animationName);
   }

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/registries/CSSKeyframesRegistry.h

@@ -1,10 +1,9 @@
 #pragma once
 
 #include <reanimated/CSS/configs/CSSKeyframesConfig.h>
-#include <reanimated/CSS/interpolation/styles/AnimationStyleInterpolator.h>
-#include <reanimated/CSS/misc/ViewStylesRepository.h>
 
-#include <memory>
+#include <functional>
+#include <optional>
 #include <string>
 #include <unordered_map>
 #include <utility>
@@ -13,17 +12,22 @@ namespace reanimated::css {
 
 class CSSKeyframesRegistry {
  public:
-  explicit CSSKeyframesRegistry(const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
-
-  const CSSKeyframesConfig &get(const std::string &animationName, const std::string &componentName);
-  void set(const std::string &animationName, const std::string &componentName, CSSKeyframesConfig &&config);
-  void remove(const std::string &animationName, const std::string &componentName);
+  std::optional<std::reference_wrapper<const CSSKeyframesConfig>> get(
+      const std::string &animationName,
+      const std::string &compoundComponentName);
+  void set(const std::string &animationName, const std::string &compoundComponentName, CSSKeyframesConfig &&config);
+  void remove(const std::string &animationName, const std::string &compoundComponentName);
 
  private:
-  using ConfigsByComponentName = std::unordered_map<std::string, CSSKeyframesConfig>;
-
-  std::unordered_map<std::string, ConfigsByComponentName> registry_;
-  const std::shared_ptr<ViewStylesRepository> viewStylesRepository_;
+  // Maps compound component name to CSSKeyframesConfig. The same keyframes object may be
+  // interpolated differently per component (different interpolators) even when the
+  // keyframes look identical. CSSKeyframesConfig holds a component-specific
+  // styleInterpolator, so configs must be stored separately per component.
+  // Compound component name combines native and JS component names (caller must build it).
+  using KeyframesByCompoundComponentName = std::unordered_map<std::string, CSSKeyframesConfig>;
+
+  // Top level: animation name. Inner level: compound component name -> config.
+  std::unordered_map<std::string, KeyframesByCompoundComponentName> registry_;
 };
 
 } // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/registries/CSSTransitionsRegistry.cpp

@@ -1,135 +1,101 @@
 #include <reanimated/CSS/registries/CSSTransitionsRegistry.h>
+#include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
+
+#include <react/debug/react_native_assert.h>
 
 #include <memory>
 #include <utility>
+#include <vector>
 
 namespace reanimated::css {
 
 CSSTransitionsRegistry::CSSTransitionsRegistry(
-    const std::shared_ptr<StaticPropsRegistry> &staticPropsRegistry,
-    const GetAnimationTimestampFunction &getCurrentTimestamp)
-    : getCurrentTimestamp_(getCurrentTimestamp), staticPropsRegistry_(staticPropsRegistry) {}
-
-bool CSSTransitionsRegistry::isEmpty() const {
-  // The registry is empty if has no registered animations and no updates
-  // stored in the updates registry
-  return UpdatesRegistry::isEmpty() && registry_.empty();
-}
-
-bool CSSTransitionsRegistry::hasUpdates() const {
-  return !runningTransitionTags_.empty() || !delayedTransitionsManager_.empty();
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository,
+    const std::shared_ptr<OperationsLoop> &loop,
+    const std::shared_ptr<CSSPlatformTransitionProxy> &platformTransitionProxy)
+    : viewStylesRepository_(viewStylesRepository), loop_(loop), platformTransitionProxy_(platformTransitionProxy) {}
+
+bool CSSTransitionsRegistry::needsFlush() const {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+  return !updatedTags_.empty();
 }
 
-void CSSTransitionsRegistry::add(const std::shared_ptr<CSSTransition> &transition) {
-  const auto &shadowNode = transition->getShadowNode();
-  const auto viewTag = shadowNode->getTag();
-
-  registry_.insert({viewTag, transition});
-  PropsObserver observer = createPropsObserver(viewTag);
-  staticPropsRegistry_->setObserver(viewTag, std::move(observer));
+void CSSTransitionsRegistry::updateConfigOrRun(
+    jsi::Runtime &rt,
+    const std::shared_ptr<const ShadowNode> &shadowNode,
+    CSSTransitionConfig &&config) {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+  const auto &transition = getOrCreateTransition(shadowNode);
+  auto initialUpdate = transition->run(rt, std::move(config), getUpdatesFromRegistry(transition->getViewTag()));
+  recordInitialUpdate(transition, initialUpdate);
 }
 
-void CSSTransitionsRegistry::remove(const Tag viewTag) {
-  removeFromUpdatesRegistry(viewTag);
-  staticPropsRegistry_->removeObserver(viewTag);
-  delayedTransitionsManager_.remove(viewTag);
-  runningTransitionTags_.erase(viewTag);
-  registry_.erase(viewTag);
-}
-
-void CSSTransitionsRegistry::updateSettings(const Tag viewTag, const PartialCSSTransitionConfig &config) {
-  const auto &transition = registry_[viewTag];
-  transition->updateSettings(config);
-
-  // Replace style overrides with the new ones if transition properties were
-  // updated (we want to keep overrides only for transitioned properties)
-  if (config.properties.has_value()) {
-    updateInUpdatesRegistry(transition, transition->getCurrentInterpolationStyle());
-  }
+void CSSTransitionsRegistry::run(
+    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const PropertyValueDynamicDiffsMap &propertyDiffs) {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+  const auto &transition = getOrCreateTransition(shadowNode);
+  auto initialUpdate = transition->run(propertyDiffs, getUpdatesFromRegistry(transition->getViewTag()));
+  recordInitialUpdate(transition, initialUpdate);
 }
 
-void CSSTransitionsRegistry::update(const double timestamp) {
-  // Activate all delayed transitions that should start now
-  activateDelayedTransitions(timestamp);
-
-  // Iterate over active transitions and update them
-  for (auto it = runningTransitionTags_.begin(); it != runningTransitionTags_.end();) {
-    const auto &viewTag = *it;
-    const auto &transition = registry_[viewTag];
-
-    const folly::dynamic &updates = transition->update(timestamp);
-    if (!updates.empty()) {
-      addUpdatesToBatch(transition->getShadowNode(), updates);
-    }
-
-    // We remove transition from running and schedule it when animation of one
-    // of properties has finished and the other one is still delayed
-    const auto &minDelay = transition->getMinDelay(timestamp);
-    if (minDelay > 0) {
-      delayedTransitionsManager_.add(timestamp + transition->getMinDelay(timestamp), viewTag);
+void CSSTransitionsRegistry::flushUpdates(UpdatesBatch &updatesBatch) {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+  const auto tags = std::exchange(updatedTags_, {});
+  for (const auto viewTag : tags) {
+    const auto it = registry_.find(viewTag);
+    if (it == registry_.end()) {
+      continue;
     }
 
-    if (transition->getState() != TransitionProgressState::Running) {
-      it = runningTransitionTags_.erase(it);
-    } else {
-      ++it;
+    auto &transition = it->second;
+    const auto updates = transition->computeCurrentLoopStyle();
+    if (!updates.empty()) {
+      addUpdatesToBatch(transition->getShadowNodeFamily(), updates);
     }
   }
+
+  flush(updatesBatch);
 }
 
-void CSSTransitionsRegistry::activateDelayedTransitions(const double timestamp) {
-  while (!delayedTransitionsManager_.empty() && delayedTransitionsManager_.top().timestamp <= timestamp) {
-    const auto [_, viewTag] = delayedTransitionsManager_.pop();
+#if REACT_NATIVE_VERSION_MINOR >= 85
+void CSSTransitionsRegistry::flushUpdates(UpdatesBatchAnimatedProps &updatesBatch) {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+  const auto tags = std::exchange(updatedTags_, {});
+  for (const auto viewTag : tags) {
+    const auto it = registry_.find(viewTag);
+    if (it == registry_.end()) {
+      continue;
+    }
 
-    // Add only these transitions which weren't removed in the meantime
-    if (registry_.find(viewTag) != registry_.end()) {
-      runningTransitionTags_.insert(viewTag);
+    auto &transition = it->second;
+    const auto updates = transition->computeCurrentLoopStyle();
+    if (!updates.empty()) {
+      addRawPropsToAnimatedPropsBatch(transition->getShadowNodeFamily(), updates);
+      // Legacy flushes merge each frame into the updates registry; animated-props flushes do not.
+      // Keep the registry current so the next transition reads a real "from" value, not the first frame only.
+      updateInUpdatesRegistry(transition, updates);
     }
   }
-}
 
-void CSSTransitionsRegistry::scheduleOrActivateTransition(const std::shared_ptr<CSSTransition> &transition) {
-  const auto viewTag = transition->getViewTag();
-  const auto currentTimestamp = getCurrentTimestamp_();
-  const auto minDelay = transition->getMinDelay(currentTimestamp);
-
-  // Remove transition from delayed (if it is already added to delayed
-  // transitions)
-  delayedTransitionsManager_.remove(viewTag);
-
-  if (minDelay > 0) {
-    delayedTransitionsManager_.add(currentTimestamp + minDelay, viewTag);
-  } else {
-    runningTransitionTags_.insert(viewTag);
-  }
+  flush(updatesBatch);
 }
+#endif
 
-PropsObserver CSSTransitionsRegistry::createPropsObserver(const Tag viewTag) {
-  return [weakThis = weak_from_this(), viewTag](const folly::dynamic &oldProps, const folly::dynamic &newProps) {
-    auto strongThis = weakThis.lock();
-    if (!strongThis) {
-      return;
-    }
-
-    const auto &transition = strongThis->registry_[viewTag];
-    const auto allowedProperties = transition->getAllowedProperties(oldProps, newProps);
-
-    const auto changedProps = getChangedProps(oldProps, newProps, allowedProperties);
+CSSTransitionsRegistry::TransitionObserver::TransitionObserver(CSSTransitionsRegistry &owner) : owner_(owner) {}
 
-    if (changedProps.changedPropertyNames.empty()) {
-      return;
-    }
-
-    {
-      std::lock_guard<std::mutex> lock{strongThis->mutex_};
+void CSSTransitionsRegistry::TransitionObserver::onTransitionUpdate(const Tag viewTag) {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+  owner_.updatedTags_.insert(viewTag);
+}
 
-      const auto &shadowNode = transition->getShadowNode();
-      const auto &lastUpdates = strongThis->getUpdatesFromRegistry(shadowNode->getTag());
-      const auto &transitionStartStyle = transition->run(changedProps, lastUpdates, strongThis->getCurrentTimestamp_());
-      strongThis->updateInUpdatesRegistry(transition, transitionStartStyle);
-      strongThis->scheduleOrActivateTransition(transition);
-    }
-  };
+void CSSTransitionsRegistry::removeTag(const Tag viewTag) {
+  const auto it = registry_.find(viewTag);
+  if (it != registry_.end()) {
+    it->second->cancel();
+  }
+  removeFromUpdatesRegistry(viewTag);
+  registry_.erase(viewTag);
 }
 
 void CSSTransitionsRegistry::updateInUpdatesRegistry(
@@ -141,17 +107,10 @@ void CSSTransitionsRegistry::updateInUpdatesRegistry(
 
   folly::dynamic filteredUpdates = folly::dynamic::object;
 
-  if (!transitionProperties.has_value()) {
-    // If transitionProperty is set to 'all' (optional has no value), we have
-    // to keep the result of the previous transition updated with the new
-    // transition starting values
-    if (!lastUpdates.empty()) {
-      filteredUpdates = lastUpdates;
-    }
-  } else if (!lastUpdates.empty()) {
+  if (!lastUpdates.empty()) {
     // Otherwise, we keep only allowed properties from the last updates
     // and update the object with the new transition starting values
-    for (const auto &prop : transitionProperties.value()) {
+    for (const auto &prop : transitionProperties) {
       if (lastUpdates.count(prop)) {
         filteredUpdates[prop] = lastUpdates[prop];
       }
@@ -161,7 +120,29 @@ void CSSTransitionsRegistry::updateInUpdatesRegistry(
   // updated object contains only allowed properties so we don't need
   // to do additional filtering here
   filteredUpdates.update(updates);
-  setInUpdatesRegistry(shadowNode, filteredUpdates);
+  setInUpdatesRegistry(shadowNode->getFamilyShared(), filteredUpdates);
+}
+
+const std::shared_ptr<CSSTransition> &CSSTransitionsRegistry::getOrCreateTransition(
+    const std::shared_ptr<const ShadowNode> &shadowNode) {
+  const auto viewTag = shadowNode->getTag();
+  if (!registry_.contains(viewTag)) {
+    registry_.emplace(
+        viewTag,
+        std::make_shared<CSSTransition>(
+            shadowNode, viewStylesRepository_, platformTransitionProxy_, loop_, transitionObserver_));
+  }
+  return registry_.at(viewTag);
+}
+
+void CSSTransitionsRegistry::recordInitialUpdate(
+    const std::shared_ptr<CSSTransition> &transition,
+    const folly::dynamic &initialUpdate) {
+  if (initialUpdate.empty()) {
+    return;
+  }
+  updateInUpdatesRegistry(transition, initialUpdate);
+  updatedTags_.insert(transition->getViewTag());
 }
 
 } // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/registries/CSSTransitionsRegistry.h

@@ -1,51 +1,64 @@
 #pragma once
 
-#include <reanimated/CSS/core/CSSTransition.h>
-#include <reanimated/CSS/registries/StaticPropsRegistry.h>
-#include <reanimated/CSS/utils/DelayedItemsManager.h>
-#include <reanimated/CSS/utils/props.h>
+#include <reanimated/CSS/configs/CSSTransitionConfig.h>
+#include <reanimated/CSS/core/transition/CSSTransition.h>
+#include <reanimated/CSS/misc/ViewStylesRepository.h>
+#include <reanimated/Fabric/updates/OperationsLoop.h>
 #include <reanimated/Fabric/updates/UpdatesRegistry.h>
-#include <reanimated/Tools/PlatformDepMethodsHolder.h>
 
 #include <memory>
-#include <set>
 #include <unordered_map>
 #include <unordered_set>
-#include <utility>
-#include <vector>
 
 namespace reanimated::css {
 
-class CSSTransitionsRegistry : public UpdatesRegistry, public std::enable_shared_from_this<CSSTransitionsRegistry> {
+class CSSTransitionsRegistry : public UpdatesRegistry {
  public:
   CSSTransitionsRegistry(
-      const std::shared_ptr<StaticPropsRegistry> &staticPropsRegistry,
-      const GetAnimationTimestampFunction &getCurrentTimestamp);
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository,
+      const std::shared_ptr<OperationsLoop> &loop,
+      const std::shared_ptr<CSSPlatformTransitionProxy> &platformTransitionProxy);
 
-  bool isEmpty() const override;
-  bool hasUpdates() const;
+  bool needsFlush() const;
 
-  void add(const std::shared_ptr<CSSTransition> &transition);
-  void updateSettings(Tag viewTag, const PartialCSSTransitionConfig &config);
-  void remove(Tag viewTag) override;
+  // TODO: In the future we want to decouple config update and run
+  void updateConfigOrRun(
+      jsi::Runtime &rt,
+      const std::shared_ptr<const ShadowNode> &shadowNode,
+      CSSTransitionConfig &&config);
+  void run(const std::shared_ptr<const ShadowNode> &shadowNode, const PropertyValueDynamicDiffsMap &propertyDiffs);
 
-  void update(double timestamp);
+  void flushUpdates(UpdatesBatch &updatesBatch);
+#if REACT_NATIVE_VERSION_MINOR >= 85
+  void flushUpdates(UpdatesBatchAnimatedProps &updatesBatch);
+#endif
 
  private:
   using Registry = std::unordered_map<Tag, std::shared_ptr<CSSTransition>>;
 
-  const GetAnimationTimestampFunction &getCurrentTimestamp_;
-  const std::shared_ptr<StaticPropsRegistry> staticPropsRegistry_;
+  class TransitionObserver : public CSSTransition::Observer {
+   public:
+    explicit TransitionObserver(CSSTransitionsRegistry &owner);
+    void onTransitionUpdate(Tag viewTag) override;
 
-  Registry registry_;
+   private:
+    CSSTransitionsRegistry &owner_;
+  };
+
+  const std::shared_ptr<ViewStylesRepository> viewStylesRepository_;
+  const std::shared_ptr<OperationsLoop> loop_;
+  const std::shared_ptr<CSSPlatformTransitionProxy> platformTransitionProxy_;
 
-  std::unordered_set<Tag> runningTransitionTags_;
-  DelayedItemsManager<Tag> delayedTransitionsManager_;
+  TransitionObserver transitionObserver_{*this};
+
+  Registry registry_;
+  // Tags reported by owned transitions between flushes.
+  std::unordered_set<Tag> updatedTags_;
 
-  void activateDelayedTransitions(double timestamp);
-  void scheduleOrActivateTransition(const std::shared_ptr<CSSTransition> &transition);
-  PropsObserver createPropsObserver(Tag viewTag);
+  void removeTag(Tag viewTag) override;
+  const std::shared_ptr<CSSTransition> &getOrCreateTransition(const std::shared_ptr<const ShadowNode> &shadowNode);
   void updateInUpdatesRegistry(const std::shared_ptr<CSSTransition> &transition, const folly::dynamic &updates);
+  void recordInitialUpdate(const std::shared_ptr<CSSTransition> &transition, const folly::dynamic &initialUpdate);
 };
 
 } // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/registries/StaticPropsRegistry.cpp

@@ -1,22 +1,21 @@
 #include <reanimated/CSS/registries/StaticPropsRegistry.h>
+#include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
 
-#include <utility>
+#include <react/debug/react_native_assert.h>
 
 namespace reanimated::css {
 
 void StaticPropsRegistry::set(jsi::Runtime &rt, const Tag viewTag, const jsi::Value &props) {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
   if (props.isNull() || props.isUndefined()) {
-    remove(viewTag);
+    registry_.erase(viewTag);
   } else {
-    const auto newProps = dynamicFromValue(rt, props);
-    if (has(viewTag)) {
-      notifyObservers(viewTag, get(viewTag), newProps);
-    }
-    registry_[viewTag] = newProps;
+    registry_[viewTag] = dynamicFromValue(rt, props);
   }
 }
 
 folly::dynamic StaticPropsRegistry::get(const Tag viewTag) const {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
   auto it = registry_.find(viewTag);
   if (it == registry_.end()) {
     return nullptr;
@@ -24,38 +23,14 @@ folly::dynamic StaticPropsRegistry::get(const Tag viewTag) const {
   return it->second;
 }
 
-bool StaticPropsRegistry::has(const Tag viewTag) const {
-  return registry_.find(viewTag) != registry_.end();
-}
-
 void StaticPropsRegistry::remove(const Tag viewTag) {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
   registry_.erase(viewTag);
 }
 
 bool StaticPropsRegistry::isEmpty() const {
-  return registry_.empty() && observers_.empty();
-}
-
-bool StaticPropsRegistry::hasObservers(const Tag viewTag) const {
-  return observers_.find(viewTag) != observers_.end();
-}
-
-void StaticPropsRegistry::setObserver(const Tag viewTag, PropsObserver observer) {
-  observers_[viewTag] = std::move(observer);
-}
-
-void StaticPropsRegistry::removeObserver(const Tag viewTag) {
-  observers_.erase(viewTag);
-}
-
-void StaticPropsRegistry::notifyObservers(
-    const Tag viewTag,
-    const folly::dynamic &oldProps,
-    const folly::dynamic &newProps) {
-  auto observerIt = observers_.find(viewTag);
-  if (observerIt != observers_.end()) {
-    observerIt->second(oldProps, newProps);
-  }
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+  return registry_.empty();
 }
 
 } // namespace reanimated::css