@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/CSS/progress/TransitionProgressProvider.cpp

@@ -0,0 +1,193 @@
+#include <reanimated/CSS/progress/TransitionProgressProvider.h>
+
+#include <limits>
+#include <memory>
+#include <string>
+#include <unordered_set>
+
+namespace reanimated::css {
+
+// TransitionPropertyProgressProvider
+
+TransitionPropertyProgressProvider::TransitionPropertyProgressProvider(
+    const double timestamp,
+    const double duration,
+    const double delay,
+    const EasingFunction &easingFunction)
+    : RawProgressProvider(timestamp, duration, delay), easingFunction_(easingFunction) {}
+
+TransitionPropertyProgressProvider::TransitionPropertyProgressProvider(
+    const double timestamp,
+    const double duration,
+    const double delay,
+    const EasingFunction &easingFunction,
+    const double reversingShorteningFactor)
+    : RawProgressProvider(timestamp, duration, delay),
+      easingFunction_(easingFunction),
+      reversingShorteningFactor_(reversingShorteningFactor) {}
+
+double TransitionPropertyProgressProvider::getGlobalProgress() const {
+  return rawProgress_.value_or(0);
+}
+
+double TransitionPropertyProgressProvider::getKeyframeProgress(const double fromOffset, const double toOffset) const {
+  if (fromOffset == toOffset) {
+    return 1;
+  }
+  return easingFunction_(getGlobalProgress());
+}
+
+double TransitionPropertyProgressProvider::getRemainingDelay(const double timestamp) const {
+  return delay_ - (timestamp - creationTimestamp_);
+}
+
+double TransitionPropertyProgressProvider::getReversingShorteningFactor() const {
+  return reversingShorteningFactor_;
+}
+
+TransitionProgressState TransitionPropertyProgressProvider::getState() const {
+  if (!rawProgress_.has_value()) {
+    return TransitionProgressState::Pending;
+  }
+  const auto rawProgress = rawProgress_.value();
+  if (rawProgress >= 1) {
+    return TransitionProgressState::Finished;
+  }
+  return TransitionProgressState::Running;
+}
+
+std::optional<double> TransitionPropertyProgressProvider::calculateRawProgress(const double timestamp) {
+  if (duration_ == 0) {
+    return 1;
+  }
+  return getElapsedTime(timestamp) / duration_;
+}
+
+double TransitionPropertyProgressProvider::getElapsedTime(const double timestamp) const {
+  return timestamp - (creationTimestamp_ + delay_);
+}
+
+// TransitionProgressProvider
+
+TransitionProgressState TransitionProgressProvider::getState() const {
+  for (const auto &[_, propertyProgressProvider] : propertyProgressProviders_) {
+    if (propertyProgressProvider->getState() == TransitionProgressState::Running) {
+      return TransitionProgressState::Running;
+    }
+  }
+  return TransitionProgressState::Pending;
+}
+
+double TransitionProgressProvider::getMinDelay(const double timestamp) const {
+  if (propertyProgressProviders_.empty()) {
+    return 0;
+  }
+  auto minDelay = std::numeric_limits<double>::max();
+
+  for (const auto &[_, propertyProgressProvider] : propertyProgressProviders_) {
+    const auto remainingDelay = propertyProgressProvider->getRemainingDelay(timestamp);
+    if (remainingDelay < minDelay) {
+      minDelay = remainingDelay;
+    }
+  }
+
+  return minDelay;
+}
+
+TransitionPropertyProgressProviders TransitionProgressProvider::getPropertyProgressProviders() const {
+  return propertyProgressProviders_;
+}
+
+std::unordered_set<std::string> TransitionProgressProvider::getRemovedProperties() const {
+  return removedProperties_;
+}
+
+void TransitionProgressProvider::discardFinishedProgressProviders() {
+  for (auto it = propertyProgressProviders_.begin(); it != propertyProgressProviders_.end();) {
+    if (it->second->getState() == TransitionProgressState::Finished) {
+      it = propertyProgressProviders_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+void TransitionProgressProvider::discardIrrelevantProgressProviders(
+    const std::unordered_set<std::string> &transitionPropertyNames) {
+  for (auto it = propertyProgressProviders_.begin(); it != propertyProgressProviders_.end();) {
+    // Remove property progress providers for properties not specified in the
+    // transition property names
+    if (transitionPropertyNames.find(it->first) == transitionPropertyNames.end()) {
+      it = propertyProgressProviders_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+void TransitionProgressProvider::runProgressProviders(
+    const double timestamp,
+    const CSSTransitionPropertiesSettings &propertiesSettings,
+    const PropertyNames &changedPropertyNames,
+    const std::unordered_set<std::string> &reversedPropertyNames) {
+  for (const auto &propertyName : changedPropertyNames) {
+    const auto propertySettingsOptional = getTransitionPropertySettings(propertiesSettings, propertyName);
+
+    if (!propertySettingsOptional.has_value()) {
+      throw std::invalid_argument("[Reanimated] Property '" + propertyName + "' is not a valid transition property");
+    }
+
+    const auto &propertySettings = propertySettingsOptional.value();
+    const auto it = propertyProgressProviders_.find(propertyName);
+
+    if (it != propertyProgressProviders_.end()) {
+      const auto &progressProvider = it->second;
+      progressProvider->update(timestamp);
+
+      if (reversedPropertyNames.find(propertyName) != reversedPropertyNames.end() &&
+          progressProvider->getState() != TransitionProgressState::Finished) {
+        // Create reversing shortening progress provider for interrupted
+        // reversing transition
+        propertyProgressProviders_.insert_or_assign(
+            propertyName, createReversingShorteningProgressProvider(timestamp, propertySettings, *progressProvider));
+        continue;
+      }
+    }
+
+    // Create progress provider with the new settings
+    propertyProgressProviders_.insert_or_assign(
+        propertyName,
+        std::make_shared<TransitionPropertyProgressProvider>(
+            timestamp, propertySettings.duration, propertySettings.delay, propertySettings.easingFunction));
+  }
+}
+
+void TransitionProgressProvider::update(const double timestamp) {
+  removedProperties_.clear();
+
+  for (const auto &[propertyName, propertyProgressProvider] : propertyProgressProviders_) {
+    propertyProgressProvider->update(timestamp);
+    if (propertyProgressProvider->getState() == TransitionProgressState::Finished) {
+      removedProperties_.insert(propertyName);
+    }
+  }
+}
+
+std::shared_ptr<TransitionPropertyProgressProvider>
+TransitionProgressProvider::createReversingShorteningProgressProvider(
+    const double timestamp,
+    const CSSTransitionPropertySettings &propertySettings,
+    const TransitionPropertyProgressProvider &existingProgressProvider) {
+  const auto oldProgress = existingProgressProvider.getKeyframeProgress(0, 1);
+  const auto oldReversingShorteningFactor = existingProgressProvider.getReversingShorteningFactor();
+  auto newReversingShorteningFactor = oldProgress * oldReversingShorteningFactor + (1 - oldReversingShorteningFactor);
+
+  return std::make_shared<TransitionPropertyProgressProvider>(
+      timestamp,
+      propertySettings.duration * newReversingShorteningFactor,
+      propertySettings.delay < 0 ? newReversingShorteningFactor * propertySettings.delay : propertySettings.delay,
+      propertySettings.easingFunction,
+      newReversingShorteningFactor);
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/progress/TransitionProgressProvider.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <reanimated/CSS/configs/CSSTransitionConfig.h>
+#include <reanimated/CSS/progress/KeyframeProgressProvider.h>
+#include <reanimated/CSS/progress/RawProgressProvider.h>
+#include <reanimated/CSS/utils/props.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace reanimated::css {
+
+enum class TransitionProgressState : std::uint8_t { Pending, Running, Finished };
+
+class TransitionPropertyProgressProvider final : public KeyframeProgressProvider, public RawProgressProvider {
+ public:
+  TransitionPropertyProgressProvider(
+      double timestamp,
+      double duration,
+      double delay,
+      const EasingFunction &easingFunction);
+  TransitionPropertyProgressProvider(
+      double timestamp,
+      double duration,
+      double delay,
+      const EasingFunction &easingFunction,
+      double reversingShorteningFactor);
+
+  double getGlobalProgress() const override;
+  double getKeyframeProgress(double fromOffset, double toOffset) const override;
+  double getRemainingDelay(double timestamp) const;
+  double getReversingShorteningFactor() const;
+  TransitionProgressState getState() const;
+
+ protected:
+  std::optional<double> calculateRawProgress(double timestamp) override;
+
+ private:
+  EasingFunction easingFunction_;
+  double reversingShorteningFactor_ = 1;
+
+  double getElapsedTime(double timestamp) const;
+};
+
+using TransitionPropertyProgressProviders =
+    std::unordered_map<std::string, std::shared_ptr<TransitionPropertyProgressProvider>>;
+
+class TransitionProgressProvider final {
+ public:
+  TransitionProgressState getState() const;
+  double getMinDelay(double timestamp) const;
+  TransitionPropertyProgressProviders getPropertyProgressProviders() const;
+  std::unordered_set<std::string> getRemovedProperties() const;
+
+  void discardFinishedProgressProviders();
+  void discardIrrelevantProgressProviders(const std::unordered_set<std::string> &transitionPropertyNames);
+  void runProgressProviders(
+      double timestamp,
+      const CSSTransitionPropertiesSettings &propertiesSettings,
+      const PropertyNames &changedPropertyNames,
+      const std::unordered_set<std::string> &reversedPropertyNames);
+  void update(double timestamp);
+
+ private:
+  TransitionPropertyProgressProviders propertyProgressProviders_;
+
+  std::unordered_set<std::string> removedProperties_;
+
+  std::shared_ptr<TransitionPropertyProgressProvider> createReversingShorteningProgressProvider(
+      double timestamp,
+      const CSSTransitionPropertySettings &propertySettings,
+      const TransitionPropertyProgressProvider &existingProgressProvider);
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,340 @@
+#include <reanimated/CSS/registries/CSSAnimationsRegistry.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace reanimated::css {
+
+bool CSSAnimationsRegistry::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 CSSAnimationsRegistry::hasUpdates() const {
+  return !runningAnimationIndicesMap_.empty() || !delayedAnimationsManager_.empty() || !animationsToRevertMap_.empty();
+}
+
+void CSSAnimationsRegistry::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) {
+  auto animationsVector = buildAnimationsVector(rt, shadowNode, animationNames, newAnimations);
+
+  const auto viewTag = shadowNode->getTag();
+  if (animationsVector.empty()) {
+    remove(viewTag);
+    return;
+  }
+
+  runningAnimationIndicesMap_[viewTag].clear();
+
+  std::vector<size_t> updatedIndices;
+  for (const auto &[index, _] : newAnimations) {
+    updatedIndices.push_back(index);
+  }
+  for (const auto &[index, _] : settingsUpdates) {
+    updatedIndices.push_back(index);
+  }
+
+  updateAnimationSettings(animationsVector, settingsUpdates, timestamp);
+  for (size_t i = 0; i < animationsVector.size(); ++i) {
+    scheduleOrActivateAnimation(i, animationsVector[i], timestamp);
+  }
+
+  auto animationToIndexMap = buildAnimationToIndexMap(animationsVector);
+  registry_.erase(viewTag);
+  registry_.emplace(viewTag, RegistryEntry{std::move(animationsVector), std::move(animationToIndexMap)});
+
+  updateViewAnimations(viewTag, updatedIndices, timestamp, false);
+  applyViewAnimationsStyle(viewTag, timestamp);
+}
+
+void CSSAnimationsRegistry::remove(const Tag viewTag) {
+  removeViewAnimations(viewTag);
+  removeFromUpdatesRegistry(viewTag);
+  registry_.erase(viewTag);
+}
+
+void CSSAnimationsRegistry::update(const double timestamp) {
+  // Activate all delayed animations that should start now
+  activateDelayedAnimations(timestamp);
+  // Update styles in the registry for views which animations were reverted
+  handleAnimationsToRevert(timestamp);
+
+  // Iterate over active animations and update them
+  for (auto it = runningAnimationIndicesMap_.begin(); it != runningAnimationIndicesMap_.end();) {
+    const auto viewTag = it->first;
+    const std::vector<size_t> animationIndices = {it->second.begin(), it->second.end()};
+    updateViewAnimations(viewTag, animationIndices, timestamp, true);
+
+    if (runningAnimationIndicesMap_[viewTag].empty()) {
+      it = runningAnimationIndicesMap_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+CSSAnimationsVector CSSAnimationsRegistry::buildAnimationsVector(
+    jsi::Runtime &rt,
+    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const std::optional<std::vector<std::string>> &animationNames,
+    const std::optional<CSSAnimationsMap> &newAnimations) const {
+  const auto registryIt = registry_.find(shadowNode->getTag());
+
+  // If animationNames has no value, that means no animations were added,
+  // removed or reordered, so we can return the current animations vector from
+  // the registry
+  if (!animationNames.has_value()) {
+    if (registryIt != registry_.end()) {
+      return registryIt->second.animationsVector;
+    }
+  }
+
+  CSSAnimationsVector animationsVector;
+  const auto &animationNamesVector = animationNames.value();
+  const auto animationNamesSize = animationNamesVector.size();
+  animationsVector.reserve(animationNamesSize);
+
+  std::unordered_map<std::string, CSSAnimationsVector> oldAnimationsMap;
+  CSSAnimationsMap emptyAnimationsMap;
+  const auto &newAnimationsMap = newAnimations.value_or(emptyAnimationsMap);
+
+  if (registryIt != registry_.end()) {
+    const auto &oldAnimations = registryIt->second.animationsVector;
+
+    // Fill the map while maintaining reverse order (for quick pop from the end)
+    for (auto it = oldAnimations.rbegin(); it != oldAnimations.rend(); ++it) {
+      oldAnimationsMap[(*it)->getName()].emplace_back(*it);
+    }
+  }
+
+  for (size_t i = 0; i < animationNamesSize; ++i) {
+    const auto &newAnimationIt = newAnimationsMap.find(i);
+    if (newAnimationIt != newAnimationsMap.end()) {
+      animationsVector.emplace_back(newAnimationIt->second);
+      continue;
+    }
+
+    const auto &name = animationNamesVector[i];
+    const auto &oldAnimationIt = oldAnimationsMap.find(name);
+
+    if (oldAnimationIt == oldAnimationsMap.end()) {
+      throw std::runtime_error(
+          "[Reanimated] There is no animation with name " + name + " available to use at index " + std::to_string(i));
+    }
+
+    animationsVector.emplace_back(oldAnimationIt->second.back());
+    oldAnimationIt->second.pop_back();
+
+    if (oldAnimationIt->second.empty()) {
+      oldAnimationsMap.erase(oldAnimationIt);
+    }
+  }
+
+  return animationsVector;
+}
+
+CSSAnimationsRegistry::AnimationToIndexMap CSSAnimationsRegistry::buildAnimationToIndexMap(
+    const CSSAnimationsVector &animationsVector) const {
+  AnimationToIndexMap animationToIndexMap;
+
+  for (size_t i = 0; i < animationsVector.size(); ++i) {
+    animationToIndexMap[animationsVector[i]] = i;
+  }
+
+  return animationToIndexMap;
+}
+
+void CSSAnimationsRegistry::updateAnimationSettings(
+    const CSSAnimationsVector &animationsVector,
+    const CSSAnimationSettingsUpdatesMap &settingsUpdates,
+    const double timestamp) {
+  for (size_t i = 0; i < animationsVector.size(); ++i) {
+    const auto &animation = animationsVector[i];
+    const auto it = settingsUpdates.find(i);
+    if (it != settingsUpdates.end()) {
+      animation->updateSettings(it->second, timestamp);
+    }
+  }
+}
+
+void CSSAnimationsRegistry::updateViewAnimations(
+    const Tag viewTag,
+    const std::vector<size_t> &animationIndices,
+    const double timestamp,
+    const bool addToBatch) {
+  folly::dynamic result = folly::dynamic::object;
+  std::shared_ptr<const ShadowNode> shadowNode = nullptr;
+  bool hasUpdates = false;
+
+  for (const auto animationIndex : animationIndices) {
+    const auto &animation = registry_[viewTag].animationsVector[animationIndex];
+    if (!shadowNode) {
+      shadowNode = animation->getShadowNode();
+    }
+    if (animation->getState(timestamp) == AnimationProgressState::Pending) {
+      animation->run(timestamp);
+    }
+
+    bool updatesAddedToBatch = false;
+    const auto updates = animation->update(timestamp);
+    const auto newState = animation->getState(timestamp);
+
+    if (newState == AnimationProgressState::Finished) {
+      // Revert changes applied during animation if there is no forwards fill
+      // mode
+      if (addToBatch && !animation->hasForwardsFillMode()) {
+        //  We also have to manually commit style values
+        // reverting the changes applied by the animation.
+        hasUpdates = addStyleUpdates(result, animation->getResetStyle(), false) || hasUpdates;
+        updatesAddedToBatch = true;
+        // We want to remove style changes applied by the animation that is
+        // finished and has no forwards fill mode. We cannot simply remove
+        // properties from the style in the registry as it may be overridden
+        // by the next animation. Instead, we are creating the new style
+        // object without reverted (finished without forwards fill mode)
+        // animations.
+        animationsToRevertMap_[viewTag].insert(animationIndex);
+      }
+    }
+
+    if (addToBatch && !updatesAddedToBatch) {
+      hasUpdates = addStyleUpdates(result, updates, true) || hasUpdates;
+    }
+    if (newState != AnimationProgressState::Running) {
+      runningAnimationIndicesMap_[viewTag].erase(animationIndex);
+    }
+  }
+
+  if (hasUpdates) {
+    addUpdatesToBatch(shadowNode, result);
+  }
+}
+
+void CSSAnimationsRegistry::scheduleOrActivateAnimation(
+    const size_t animationIndex,
+    const std::shared_ptr<CSSAnimation> &animation,
+    const double timestamp) {
+  // Remove the animation from delayed (if it is already added to
+  // delayed animations)
+  delayedAnimationsManager_.remove(animation);
+
+  const auto startTimestamp = animation->getStartTimestamp(timestamp);
+
+  if (startTimestamp > timestamp) {
+    // If the animation is delayed, schedule it for activation
+    // (Only if it isn't paused)
+    if (animation->getState(timestamp) != AnimationProgressState::Paused) {
+      delayedAnimationsManager_.add(startTimestamp, animation);
+    }
+  } else {
+    const auto viewTag = animation->getShadowNode()->getTag();
+    runningAnimationIndicesMap_[viewTag].insert(animationIndex);
+  }
+}
+
+void CSSAnimationsRegistry::removeViewAnimations(const Tag viewTag) {
+  const auto it = registry_.find(viewTag);
+  if (it == registry_.end()) {
+    return;
+  }
+
+  for (const auto &animation : it->second.animationsVector) {
+    delayedAnimationsManager_.remove(animation);
+  }
+  runningAnimationIndicesMap_.erase(viewTag);
+}
+
+void CSSAnimationsRegistry::applyViewAnimationsStyle(const Tag viewTag, const double timestamp) {
+  const auto it = registry_.find(viewTag);
+  // Remove the style from the registry if there are no animations for the view
+  if (it == registry_.end() || it->second.animationsVector.empty()) {
+    removeFromUpdatesRegistry(viewTag);
+    return;
+  }
+
+  folly::dynamic updatedStyle = folly::dynamic::object;
+  std::shared_ptr<const ShadowNode> shadowNode = nullptr;
+
+  for (const auto &animation : it->second.animationsVector) {
+    const auto startTimestamp = animation->getStartTimestamp(timestamp);
+
+    folly::dynamic style;
+    const auto &currentState = animation->getState(timestamp);
+    if (startTimestamp > timestamp && animation->hasBackwardsFillMode()) {
+      style = animation->getBackwardsFillStyle();
+    } else if (
+        currentState == AnimationProgressState::Running ||
+        // Animation is paused after start (was running before)
+        (currentState == AnimationProgressState::Paused && timestamp >= animation->getStartTimestamp(timestamp)) ||
+        // Animation is finished and has fill forwards fill mode
+        (currentState == AnimationProgressState::Finished && animation->hasForwardsFillMode())) {
+      style = animation->getCurrentInterpolationStyle();
+    }
+
+    if (!shadowNode) {
+      shadowNode = animation->getShadowNode();
+    }
+    if (style.isObject()) {
+      updatedStyle.update(style);
+    }
+  }
+
+  setInUpdatesRegistry(shadowNode, updatedStyle);
+}
+
+void CSSAnimationsRegistry::activateDelayedAnimations(const double timestamp) {
+  while (!delayedAnimationsManager_.empty() && delayedAnimationsManager_.top().timestamp <= timestamp) {
+    const auto [_, animation] = delayedAnimationsManager_.pop();
+    const auto viewTag = animation->getShadowNode()->getTag();
+
+    // Add only these animations which weren't removed in the meantime
+    if (registry_.find(viewTag) == registry_.end()) {
+      continue;
+    }
+
+    const auto &animationToIndexMap = registry_[viewTag].animationToIndexMap;
+    if (animationToIndexMap.find(animation) == animationToIndexMap.end()) {
+      continue;
+    }
+
+    const auto animationIndex = animationToIndexMap.at(animation);
+    runningAnimationIndicesMap_[viewTag].insert(animationIndex);
+  }
+}
+
+void CSSAnimationsRegistry::handleAnimationsToRevert(const double timestamp) {
+  for (const auto &[viewTag, _] : animationsToRevertMap_) {
+    applyViewAnimationsStyle(viewTag, timestamp);
+  }
+  animationsToRevertMap_.clear();
+}
+
+bool CSSAnimationsRegistry::addStyleUpdates(
+    folly::dynamic &target,
+    const folly::dynamic &updates,
+    bool shouldOverride) {
+  if (!updates.isObject()) {
+    return false;
+  }
+
+  bool hasUpdates = false;
+  for (const auto &[propertyName, propertyValue] : updates.items()) {
+    if (shouldOverride || !target.count(propertyName) || target[propertyName].isNull()) {
+      target[propertyName] = propertyValue;
+      hasUpdates = true;
+    }
+  }
+
+  return hasUpdates;
+}
+
+} // namespace reanimated::css

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

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <reanimated/CSS/configs/CSSAnimationConfig.h>
+#include <reanimated/CSS/core/CSSAnimation.h>
+#include <reanimated/CSS/utils/DelayedItemsManager.h>
+#include <reanimated/CSS/utils/props.h>
+#include <reanimated/Fabric/updates/UpdatesRegistry.h>
+
+#include <memory>
+#include <set>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+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> {
+ public:
+  using SettingsUpdates = std::vector<std::pair<size_t, PartialCSSAnimationSettings>>;
+
+  bool isEmpty() const override;
+  bool hasUpdates() 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;
+
+  void update(double timestamp);
+
+ 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;
+  };
+
+  using Registry = std::unordered_map<Tag, RegistryEntry>;
+
+  Registry registry_;
+
+  RunningAnimationIndicesMap runningAnimationIndicesMap_;
+  AnimationsToRevertMap animationsToRevertMap_;
+  DelayedItemsManager<std::shared_ptr<CSSAnimation>> delayedAnimationsManager_;
+
+  CSSAnimationsVector buildAnimationsVector(
+      jsi::Runtime &rt,
+      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,
+      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);
+};
+
+} // namespace reanimated::css