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

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/configs/CSSTransitionConfig.cpp

@@ -1,87 +1,54 @@
 #include <reanimated/CSS/configs/CSSTransitionConfig.h>
-
-#include <string>
+#include <reanimated/CSS/configs/common.h>
+#include <reanimated/CSS/utils/props.h>
 
 namespace reanimated::css {
 
-std::optional<CSSTransitionPropertySettings> getTransitionPropertySettings(
-    const CSSTransitionPropertiesSettings &propertiesSettings,
-    const std::string &propName) {
-  // Try to use property specific settings first
-  const auto &propIt = propertiesSettings.find(propName);
-  if (propIt != propertiesSettings.end()) {
-    return propIt->second;
-  }
-  // Fallback to "all" settings if no property specific settings are available
-  const auto &allIt = propertiesSettings.find("all");
-  if (allIt != propertiesSettings.end()) {
-    return allIt->second;
-  }
-  // Or return nullopt if no settings are available
-  return std::nullopt;
-}
-
-TransitionProperties getProperties(jsi::Runtime &rt, const jsi::Object &config) {
-  const auto transitionProperty = config.getProperty(rt, "properties");
-
-  if (transitionProperty.isObject()) {
-    PropertyNames properties;
-
-    const auto propertiesArray = transitionProperty.asObject(rt).asArray(rt);
-    const auto propertiesCount = propertiesArray.size(rt);
-    for (size_t i = 0; i < propertiesCount; ++i) {
-      properties.emplace_back(propertiesArray.getValueAtIndex(rt, i).asString(rt).utf8(rt));
-    }
-
-    return properties;
-  }
-
-  return std::nullopt;
-}
-
 bool getAllowDiscrete(jsi::Runtime &rt, const jsi::Object &config) {
   return config.getProperty(rt, "allowDiscrete").asBool();
 }
 
-CSSTransitionPropertiesSettings parseCSSTransitionPropertiesSettings(jsi::Runtime &rt, const jsi::Object &settings) {
-  CSSTransitionPropertiesSettings result;
-
-  const auto propertyNames = settings.getPropertyNames(rt);
+CSSTransitionConfig
+parseCSSTransitionConfig(jsi::Runtime &rt, const std::string &componentName, const jsi::Value &config) {
+  const auto configObj = config.asObject(rt);
+  const auto propertyNames = configObj.getPropertyNames(rt);
   const auto propertiesCount = propertyNames.size(rt);
 
+  CSSTransitionConfig result;
+
   for (size_t i = 0; i < propertiesCount; ++i) {
     const auto propertyName = propertyNames.getValueAtIndex(rt, i).asString(rt).utf8(rt);
-    const auto propertySettings = settings.getProperty(rt, jsi::PropNameID::forUtf8(rt, propertyName)).asObject(rt);
+    const auto propertyValue = configObj.getProperty(rt, jsi::PropNameID::forUtf8(rt, propertyName));
 
-    result.emplace(
-        propertyName,
-        CSSTransitionPropertySettings{
-            getDuration(rt, propertySettings),
-            getTimingFunction(rt, propertySettings),
-            getDelay(rt, propertySettings),
-            getAllowDiscrete(rt, propertySettings)});
-  }
+    if (propertyValue.isNull() || propertyValue.isUndefined()) {
+      result.removedProperties.emplace_back(propertyName);
+      continue;
+    }
 
-  return result;
-}
+    const auto propertySettingsObj = propertyValue.asObject(rt);
+    const auto allowDiscrete = getAllowDiscrete(rt, propertySettingsObj);
 
-CSSTransitionConfig parseCSSTransitionConfig(jsi::Runtime &rt, const jsi::Value &config) {
-  const auto configObj = config.asObject(rt);
-  return CSSTransitionConfig{
-      getProperties(rt, configObj),
-      parseCSSTransitionPropertiesSettings(rt, configObj.getProperty(rt, "settings").asObject(rt))};
-}
+    // Inherently-discrete properties without allowDiscrete are not transitioned;
+    // route them to removedProperties so any active animation cleans up.
+    if (!allowDiscrete && isDiscreteProperty(propertyName, componentName)) {
+      result.removedProperties.emplace_back(propertyName);
+      continue;
+    }
 
-PartialCSSTransitionConfig parsePartialCSSTransitionConfig(jsi::Runtime &rt, const jsi::Value &partialConfig) {
-  const auto partialObj = partialConfig.asObject(rt);
+    const auto valueArray = propertySettingsObj.getProperty(rt, "value").asObject(rt).asArray(rt);
+    auto oldValue = valueArray.getValueAtIndex(rt, 0);
+    auto newValue = valueArray.getValueAtIndex(rt, 1);
 
-  PartialCSSTransitionConfig result;
+    result.changedPropertiesSettings.emplace(
+        propertyName,
+        CSSTransitionPropertySettings{
+            getDuration(rt, propertySettingsObj),
+            getEasingConfig(rt, propertySettingsObj),
+            getDelay(rt, propertySettingsObj),
+            allowDiscrete,
+        });
 
-  if (partialObj.hasProperty(rt, "properties")) {
-    result.properties = getProperties(rt, partialObj);
-  }
-  if (partialObj.hasProperty(rt, "settings")) {
-    result.settings = parseCSSTransitionPropertiesSettings(rt, partialObj.getProperty(rt, "settings").asObject(rt));
+    result.changedProperties.emplace(propertyName, std::make_pair(std::move(oldValue), std::move(newValue)));
   }
 
   return result;

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/configs/CSSTransitionConfig.h

@@ -1,43 +1,50 @@
 #pragma once
 
-#include <reanimated/CSS/common/definitions.h>
 #include <reanimated/CSS/configs/common.h>
-#include <reanimated/CSS/easing/EasingFunctions.h>
 
+#include <folly/dynamic.h>
+#include <jsi/jsi.h>
 #include <string>
 #include <unordered_map>
+#include <utility>
+#include <vector>
 
 namespace reanimated::css {
 
 struct CSSTransitionPropertySettings {
   double duration;
-  EasingFunction easingFunction;
+  EasingConfig easingConfig;
   double delay;
   bool allowDiscrete;
 };
 
-using CSSTransitionPropertiesSettings = std::unordered_map<std::string, CSSTransitionPropertySettings>;
+using PropertyValueDiff = std::pair<jsi::Value, jsi::Value>;
+/** TODO: unify folly::dynamic and jsi::value versions */
+using PropertyValueDynamicDiff = std::pair<folly::dynamic, folly::dynamic>;
 
-struct CSSTransitionConfig {
-  TransitionProperties properties;
-  CSSTransitionPropertiesSettings settings;
-};
-
-struct PartialCSSTransitionConfig {
-  std::optional<TransitionProperties> properties;
-  std::optional<CSSTransitionPropertiesSettings> settings;
-};
+using PropertyValueDiffsMap = std::unordered_map<std::string, PropertyValueDiff>;
+/** TODO: unify folly::dynamic and jsi::value versions */
+using PropertyValueDynamicDiffsMap = std::unordered_map<std::string, PropertyValueDynamicDiff>;
 
-std::optional<CSSTransitionPropertySettings> getTransitionPropertySettings(
-    const CSSTransitionPropertiesSettings &propertiesSettings,
-    const std::string &propName);
+using PropertiesSettingsMap = std::unordered_map<std::string, CSSTransitionPropertySettings>;
 
-TransitionProperties getProperties(jsi::Runtime &rt, const jsi::Object &config);
-
-CSSTransitionPropertiesSettings parseCSSTransitionPropertiesSettings(jsi::Runtime &rt, const jsi::Object &settings);
-
-CSSTransitionConfig parseCSSTransitionConfig(jsi::Runtime &rt, const jsi::Value &config);
+struct CSSTransitionConfig {
+  PropertiesSettingsMap changedPropertiesSettings;
+  PropertyValueDiffsMap changedProperties;
+  std::vector<std::string> removedProperties;
+
+  bool hasSettingsUpdates() const {
+    return !changedPropertiesSettings.empty() || !removedProperties.empty();
+  }
+  bool hasValueUpdates() const {
+    return !changedProperties.empty();
+  }
+  bool empty() const {
+    return !hasSettingsUpdates() && !hasValueUpdates();
+  }
+};
 
-PartialCSSTransitionConfig parsePartialCSSTransitionConfig(jsi::Runtime &rt, const jsi::Value &partialConfig);
+CSSTransitionConfig
+parseCSSTransitionConfig(jsi::Runtime &rt, const std::string &componentName, const jsi::Value &config);
 
 } // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/configs/common.cpp

@@ -1,17 +1,29 @@
 #include <reanimated/CSS/configs/common.h>
 
+#include <react/renderer/componentregistry/componentNameByReactViewName.h>
+
+using facebook::react::componentNameByReactViewName;
+
 namespace reanimated::css {
 
 double getDuration(jsi::Runtime &rt, const jsi::Object &config) {
   return config.getProperty(rt, "duration").asNumber();
 }
 
-EasingFunction getTimingFunction(jsi::Runtime &rt, const jsi::Object &config) {
-  return createEasingFunction(rt, config.getProperty(rt, "timingFunction"));
+EasingConfig getEasingConfig(jsi::Runtime &rt, const jsi::Object &config) {
+  return getEasingConfig(rt, config.getProperty(rt, "timingFunction"));
 }
 
 double getDelay(jsi::Runtime &rt, const jsi::Object &config) {
   return config.getProperty(rt, "delay").asNumber();
 }
 
+std::pair<std::string, std::string> splitCompoundComponentName(const std::string &compoundComponentName) {
+  const auto pos = compoundComponentName.find('$');
+  if (pos == std::string::npos) {
+    return {compoundComponentName, ""};
+  }
+  return {compoundComponentName.substr(0, pos), compoundComponentName.substr(pos + 1)};
+}
+
 } // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/configs/common.h

@@ -1,13 +1,19 @@
 #pragma once
 
-#include <reanimated/CSS/easing/EasingFunctions.h>
+#include <jsi/jsi.h>
+#include <reanimated/CSS/easing/EasingConfigs.h>
+
+#include <string>
+#include <utility>
 
 namespace reanimated::css {
 
 double getDuration(jsi::Runtime &rt, const jsi::Object &config);
 
-EasingFunction getTimingFunction(jsi::Runtime &rt, const jsi::Object &config);
+EasingConfig getEasingConfig(jsi::Runtime &rt, const jsi::Object &config);
 
 double getDelay(jsi::Runtime &rt, const jsi::Object &config);
 
+std::pair<std::string, std::string> splitCompoundComponentName(const std::string &compoundComponentName);
+
 } // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/core/CSSAnimation.cpp

@@ -1,127 +1,86 @@
 #include <reanimated/CSS/core/CSSAnimation.h>
+#include <reanimated/CSS/core/CSSLoopAnimation.h>
+#include <reanimated/Tools/FeatureFlags.h>
 
 #include <memory>
-#include <string>
 #include <utility>
 
 namespace reanimated::css {
 
 CSSAnimation::CSSAnimation(
-    jsi::Runtime &rt,
-    std::shared_ptr<const ShadowNode> shadowNode,
+    const Tag viewTag,
     std::string animationName,
     const CSSKeyframesConfig &cssKeyframesConfig,
     const CSSAnimationSettings &settings,
+    Observer &observer,
+    const std::shared_ptr<CSSPlatformAnimationFactory> &platformAnimationFactory,
     const double timestamp)
-    : name_(std::move(animationName)),
-      shadowNode_(std::move(shadowNode)),
-      fillMode_(settings.fillMode),
-      styleInterpolator_(cssKeyframesConfig.styleInterpolator),
-      progressProvider_(std::make_shared<AnimationProgressProvider>(
-          timestamp,
-          settings.duration,
-          settings.delay,
-          settings.iterationCount,
-          settings.direction,
-          settings.easingFunction,
-          cssKeyframesConfig.keyframeEasingFunctions)) {
-  if (settings.playState == AnimationPlayState::Paused) {
-    progressProvider_->pause(timestamp);
-  }
-}
-
-const std::string &CSSAnimation::getName() const {
-  return name_;
-}
-
-std::shared_ptr<const ShadowNode> CSSAnimation::getShadowNode() const {
-  return shadowNode_;
+    : viewTag_(viewTag),
+      name_(std::move(animationName)),
+      keyframesConfig_(cssKeyframesConfig),
+      settings_(std::make_shared<CSSAnimationSettings>(settings)),
+      styleInterpolator_(cssKeyframesConfig.styleInterpolatorFactory->create()),
+      loopAnimation_(std::make_shared<CSSLoopAnimation>(
+          viewTag,
+          styleInterpolator_,
+          settings_,
+          cssKeyframesConfig.keyframeEasingConfigs,
+          observer,
+          timestamp)),
+      platformAnimationFactory_(platformAnimationFactory) {
+  updatePropertyRouting();
 }
 
-double CSSAnimation::getStartTimestamp(const double timestamp) const {
-  return progressProvider_->getStartTimestamp(timestamp);
+AnimationProgressState CSSAnimation::getState() const {
+  return loopAnimation_->getState();
 }
 
-AnimationProgressState CSSAnimation::getState(double timestamp) const {
-  return progressProvider_->getState(timestamp);
+folly::dynamic CSSAnimation::getBackwardsFillStyle() const {
+  return isReversed() ? styleInterpolator_->getLastKeyframeValue() : styleInterpolator_->getFirstKeyframeValue();
 }
 
-bool CSSAnimation::isReversed() const {
-  const auto direction = progressProvider_->getDirection();
-  return direction == AnimationDirection::Reverse || direction == AnimationDirection::AlternateReverse;
+folly::dynamic CSSAnimation::getCurrentInterpolationStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const {
+  return loopAnimation_->getCurrentInterpolationStyle(shadowNode);
 }
 
-bool CSSAnimation::hasForwardsFillMode() const {
-  return fillMode_ == AnimationFillMode::Forwards || fillMode_ == AnimationFillMode::Both;
+folly::dynamic CSSAnimation::getResetStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const {
+  return keyframesConfig_.styleInterpolatorFactory->getResetStyle(shadowNode);
 }
 
-bool CSSAnimation::hasBackwardsFillMode() const {
-  return fillMode_ == AnimationFillMode::Backwards || fillMode_ == AnimationFillMode::Both;
+void CSSAnimation::schedule(OperationsLoop &loop) {
+  loopAnimation_->schedule(loop);
+  if (platformAnimation_) {
+    platformAnimation_->schedule(loop.resolveTimestamp() + settings_->delay);
+  }
 }
 
-folly::dynamic CSSAnimation::getCurrentInterpolationStyle() const {
-  return styleInterpolator_->interpolate(shadowNode_, progressProvider_, FALLBACK_INTERPOLATION_THRESHOLD);
+void CSSAnimation::unschedule(OperationsLoop &loop) {
+  loopAnimation_->unschedule(loop);
+  if (platformAnimation_) {
+    platformAnimation_->unschedule();
+  }
 }
 
-folly::dynamic CSSAnimation::getBackwardsFillStyle() const {
-  return isReversed() ? styleInterpolator_->getLastKeyframeValue() : styleInterpolator_->getFirstKeyframeValue();
+void CSSAnimation::updateSettings(const PartialCSSAnimationSettings &updatedSettings, const double timestamp) {
+  loopAnimation_->updateSettings(updatedSettings, timestamp);
 }
 
-folly::dynamic CSSAnimation::getResetStyle() const {
-  return styleInterpolator_->getResetStyle(shadowNode_);
+bool CSSAnimation::isReversed() const {
+  return settings_->direction == AnimationDirection::Reverse ||
+      settings_->direction == AnimationDirection::AlternateReverse;
 }
 
-void CSSAnimation::run(const double timestamp) {
-  if (progressProvider_->getState(timestamp) == AnimationProgressState::Finished) {
+void CSSAnimation::updatePropertyRouting() {
+  if (!platformAnimationFactory_) {
     return;
   }
-  progressProvider_->play(timestamp);
-}
-
-folly::dynamic CSSAnimation::update(const double timestamp) {
-  progressProvider_->update(timestamp);
-
-  // Check if the animation has not started yet because of the delay
-  // (In general, it shouldn't be activated until the delay has passed but we
-  // add this check to make sure that animation doesn't start with the negative
-  // progress)
-  if (progressProvider_->getState(timestamp) == AnimationProgressState::Pending) {
-    return hasBackwardsFillMode() ? getBackwardsFillStyle() : folly::dynamic();
-  }
-
-  return styleInterpolator_->interpolate(shadowNode_, progressProvider_, FALLBACK_INTERPOLATION_THRESHOLD);
-}
-
-void CSSAnimation::updateSettings(const PartialCSSAnimationSettings &updatedSettings, const double timestamp) {
-  progressProvider_->resetProgress();
-
-  if (updatedSettings.duration.has_value()) {
-    progressProvider_->setDuration(updatedSettings.duration.value());
-  }
-  if (updatedSettings.easingFunction.has_value()) {
-    progressProvider_->setEasingFunction(updatedSettings.easingFunction.value());
-  }
-  if (updatedSettings.delay.has_value()) {
-    progressProvider_->setDelay(updatedSettings.delay.value());
-  }
-  if (updatedSettings.iterationCount.has_value()) {
-    progressProvider_->setIterationCount(updatedSettings.iterationCount.value());
-  }
-  if (updatedSettings.direction.has_value()) {
-    progressProvider_->setDirection(updatedSettings.direction.value());
-  }
-  if (updatedSettings.fillMode.has_value()) {
-    fillMode_ = updatedSettings.fillMode.value();
-  }
-  if (updatedSettings.playState.has_value()) {
-    if (updatedSettings.playState.value() == AnimationPlayState::Paused) {
-      progressProvider_->pause(timestamp);
-    } else {
-      progressProvider_->play(timestamp);
-    }
+  if constexpr (!StaticFeatureFlags::getFlag("IOS_CSS_CORE_ANIMATION")) {
+    return;
   }
-
-  progressProvider_->update(timestamp);
+  const auto &allProperties = keyframesConfig_.styleInterpolatorFactory->getAllPropertyNames();
+  auto result = platformAnimationFactory_->resolve(viewTag_, name_, allProperties, keyframesConfig_, settings_);
+  platformAnimation_ = result.animation;
+  loopAnimation_->setAnimatedProperties(result.remainingProperties);
 }
 
 } // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/core/CSSAnimation.h

@@ -2,50 +2,75 @@
 
 #include <reanimated/CSS/configs/CSSAnimationConfig.h>
 #include <reanimated/CSS/configs/CSSKeyframesConfig.h>
+#include <reanimated/CSS/core/CSSPlatformAnimation.h>
+#include <reanimated/CSS/core/CSSPlatformAnimationFactory.h>
+#include <reanimated/CSS/interpolation/styles/AnimationStyleInterpolator.h>
 #include <reanimated/CSS/progress/AnimationProgressProvider.h>
+#include <reanimated/Fabric/updates/OperationsLoop.h>
 
 #include <memory>
 #include <string>
 
 namespace reanimated::css {
 
+class CSSLoopAnimation;
+
 class CSSAnimation {
  public:
-  static constexpr double FALLBACK_INTERPOLATION_THRESHOLD = 0.5;
+  class Observer {
+   public:
+    virtual ~Observer() = default;
+    virtual void onAnimationUpdate(Tag viewTag) = 0;
+    // Called when the animation finishes without `forwards` fill mode and will
+    // need to be reverted to the underlying style on the next flush.
+    virtual void onAnimationNeedsRevert(Tag viewTag) = 0;
+  };
 
   CSSAnimation(
-      jsi::Runtime &rt,
-      std::shared_ptr<const ShadowNode> shadowNode,
+      Tag viewTag,
       std::string animationName,
       const CSSKeyframesConfig &cssKeyframesConfig,
       const CSSAnimationSettings &settings,
+      Observer &observer,
+      const std::shared_ptr<CSSPlatformAnimationFactory> &platformAnimationFactory,
       double timestamp);
 
-  const std::string &getName() const;
-  std::shared_ptr<const ShadowNode> getShadowNode() const;
+  const std::string &getName() const {
+    return name_;
+  }
 
-  double getStartTimestamp(double timestamp) const;
-  AnimationProgressState getState(double timestamp) const;
-  bool isReversed() const;
+  AnimationProgressState getState() const;
 
-  bool hasForwardsFillMode() const;
-  bool hasBackwardsFillMode() const;
+  bool hasForwardsFillMode() const {
+    return settings_->hasForwardsFillMode();
+  }
+
+  bool hasBackwardsFillMode() const {
+    return settings_->hasBackwardsFillMode();
+  }
 
-  folly::dynamic getCurrentInterpolationStyle() const;
   folly::dynamic getBackwardsFillStyle() const;
-  folly::dynamic getResetStyle() const;
+  folly::dynamic getCurrentInterpolationStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const;
+  folly::dynamic getResetStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const;
+
+  void schedule(OperationsLoop &loop);
+  void unschedule(OperationsLoop &loop);
 
-  void run(double timestamp);
-  folly::dynamic update(double timestamp);
   void updateSettings(const PartialCSSAnimationSettings &updatedSettings, double timestamp);
 
  private:
+  const Tag viewTag_;
   const std::string name_;
-  const std::shared_ptr<const ShadowNode> shadowNode_;
-  AnimationFillMode fillMode_;
-
+  const CSSKeyframesConfig keyframesConfig_;
+  const std::shared_ptr<CSSAnimationSettings> settings_;
+  const std::shared_ptr<OperationsLoop> loop_;
   const std::shared_ptr<AnimationStyleInterpolator> styleInterpolator_;
-  const std::shared_ptr<AnimationProgressProvider> progressProvider_;
+  const std::shared_ptr<CSSLoopAnimation> loopAnimation_;
+  const std::shared_ptr<CSSPlatformAnimationFactory> platformAnimationFactory_;
+  std::shared_ptr<CSSPlatformAnimation> platformAnimation_;
+
+  bool isReversed() const;
+  void updatePropertyRouting();
 };
 
 } // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/core/CSSAnimationsGroup.cpp

@@ -0,0 +1,63 @@
+#include <reanimated/CSS/core/CSSAnimationsGroup.h>
+
+#include <utility>
+
+namespace reanimated::css {
+
+CSSAnimationsGroup::CSSAnimationsGroup(std::shared_ptr<const ShadowNode> shadowNode, CSSAnimationsVector animations)
+    : shadowNode_(std::move(shadowNode)), animations_(std::move(animations)) {}
+
+const CSSAnimationsVector &CSSAnimationsGroup::getAnimations() const {
+  return animations_;
+}
+
+ShadowNodeFamily::Shared CSSAnimationsGroup::getShadowNodeFamily() const {
+  return shadowNode_->getFamilyShared();
+}
+
+void CSSAnimationsGroup::updateSettings(const CSSAnimationSettingsUpdatesMap &settingsUpdates, const double timestamp) {
+  for (size_t i = 0; i < animations_.size(); ++i) {
+    const auto it = settingsUpdates.find(i);
+    if (it != settingsUpdates.end()) {
+      animations_[i]->updateSettings(it->second, timestamp);
+    }
+  }
+}
+
+void CSSAnimationsGroup::schedule(OperationsLoop &loop) {
+  for (const auto &animation : animations_) {
+    animation->schedule(loop);
+  }
+}
+
+void CSSAnimationsGroup::unschedule(OperationsLoop &loop) const {
+  for (const auto &animation : animations_) {
+    animation->unschedule(loop);
+  }
+}
+
+folly::dynamic CSSAnimationsGroup::computeStyle(bool includeResetStyles) const {
+  folly::dynamic style = folly::dynamic::object;
+
+  for (const auto &animation : animations_) {
+    const auto state = animation->getState();
+
+    if (state == AnimationProgressState::Running || state == AnimationProgressState::Paused ||
+        (state == AnimationProgressState::Finished && animation->hasForwardsFillMode())) {
+      style.update(animation->getCurrentInterpolationStyle(shadowNode_));
+    } else if (state == AnimationProgressState::Pending && animation->hasBackwardsFillMode()) {
+      style.update(animation->getBackwardsFillStyle());
+    } else if (state == AnimationProgressState::Finished && includeResetStyles) {
+      const auto resetStyle = animation->getResetStyle(shadowNode_);
+      for (const auto &[key, value] : resetStyle.items()) {
+        if (!style.count(key)) {
+          style[key] = value;
+        }
+      }
+    }
+  }
+
+  return style;
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/core/CSSAnimationsGroup.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <reanimated/CSS/configs/CSSAnimationConfig.h>
+#include <reanimated/CSS/core/CSSAnimation.h>
+
+#include <folly/dynamic.h>
+#include <react/renderer/core/ShadowNode.h>
+
+#include <memory>
+#include <vector>
+
+namespace reanimated::css {
+
+using CSSAnimationsVector = std::vector<std::shared_ptr<CSSAnimation>>;
+
+class CSSAnimationsGroup {
+ public:
+  CSSAnimationsGroup(std::shared_ptr<const ShadowNode> shadowNode, CSSAnimationsVector animations);
+
+  const CSSAnimationsVector &getAnimations() const;
+  ShadowNodeFamily::Shared getShadowNodeFamily() const;
+
+  void schedule(OperationsLoop &loop);
+  void unschedule(OperationsLoop &loop) const;
+  void updateSettings(const CSSAnimationSettingsUpdatesMap &settingsUpdates, double timestamp);
+  // Computes the combined style from all animations.
+  // When includeResetStyles is true, finished animations without forwards fill
+  // contribute their original (pre-animation) property values — these should be
+  // committed once to revert the visual changes applied by the animation.
+  folly::dynamic computeStyle(bool includeResetStyles = false) const;
+
+ private:
+  std::shared_ptr<const ShadowNode> shadowNode_;
+  CSSAnimationsVector animations_;
+};
+
+} // namespace reanimated::css