@react-native-ohos/react-native-reanimated 4.0.1 → 4.0.2

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

@@ -1,51 +1,51 @@
-#pragma once
-
-#include <reanimated/CSS/configs/CSSAnimationConfig.h>
-#include <reanimated/CSS/configs/CSSKeyframesConfig.h>
-#include <reanimated/CSS/progress/AnimationProgressProvider.h>
-
-#include <memory>
-#include <string>
-
-namespace reanimated::css {
-
-class CSSAnimation {
- public:
-  static constexpr double FALLBACK_INTERPOLATION_THRESHOLD = 0.5;
-
-  CSSAnimation(
-      jsi::Runtime &rt,
-      std::shared_ptr<const ShadowNode> shadowNode,
-      std::string animationName,
-      const CSSKeyframesConfig &cssKeyframesConfig,
-      const CSSAnimationSettings &settings,
-      double timestamp);
-
-  const std::string &getName() const;
-  std::shared_ptr<const ShadowNode> getShadowNode() const;
-
-  double getStartTimestamp(double timestamp) const;
-  AnimationProgressState getState(double timestamp) const;
-  bool isReversed() const;
-
-  bool hasForwardsFillMode() const;
-  bool hasBackwardsFillMode() const;
-
-  folly::dynamic getCurrentInterpolationStyle() const;
-  folly::dynamic getBackwardsFillStyle() const;
-  folly::dynamic getResetStyle() const;
-
-  void run(double timestamp);
-  folly::dynamic update(double timestamp);
-  void updateSettings(const PartialCSSAnimationSettings &updatedSettings, double timestamp);
-
- private:
-  const std::string name_;
-  const std::shared_ptr<const ShadowNode> shadowNode_;
-  AnimationFillMode fillMode_;
-
-  const std::shared_ptr<AnimationStyleInterpolator> styleInterpolator_;
-  const std::shared_ptr<AnimationProgressProvider> progressProvider_;
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/configs/CSSAnimationConfig.h>
+#include <reanimated/CSS/configs/CSSKeyframesConfig.h>
+#include <reanimated/CSS/progress/AnimationProgressProvider.h>
+
+#include <memory>
+#include <string>
+
+namespace reanimated::css {
+
+class CSSAnimation {
+ public:
+  static constexpr double FALLBACK_INTERPOLATION_THRESHOLD = 0.5;
+
+  CSSAnimation(
+      jsi::Runtime &rt,
+      std::shared_ptr<const ShadowNode> shadowNode,
+      std::string animationName,
+      const CSSKeyframesConfig &cssKeyframesConfig,
+      const CSSAnimationSettings &settings,
+      double timestamp);
+
+  const std::string &getName() const;
+  std::shared_ptr<const ShadowNode> getShadowNode() const;
+
+  double getStartTimestamp(double timestamp) const;
+  AnimationProgressState getState(double timestamp) const;
+  bool isReversed() const;
+
+  bool hasForwardsFillMode() const;
+  bool hasBackwardsFillMode() const;
+
+  folly::dynamic getCurrentInterpolationStyle() const;
+  folly::dynamic getBackwardsFillStyle() const;
+  folly::dynamic getResetStyle() const;
+
+  void run(double timestamp);
+  folly::dynamic update(double timestamp);
+  void updateSettings(const PartialCSSAnimationSettings &updatedSettings, double timestamp);
+
+ private:
+  const std::string name_;
+  const std::shared_ptr<const ShadowNode> shadowNode_;
+  AnimationFillMode fillMode_;
+
+  const std::shared_ptr<AnimationStyleInterpolator> styleInterpolator_;
+  const std::shared_ptr<AnimationProgressProvider> progressProvider_;
+};
+
+} // namespace reanimated::css

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

@@ -1,145 +1,145 @@
-#include <reanimated/CSS/core/CSSTransition.h>
-
-#include <memory>
-#include <string>
-#include <unordered_set>
-#include <utility>
-
-namespace reanimated::css {
-
-CSSTransition::CSSTransition(
-    std::shared_ptr<const ShadowNode> shadowNode,
-    const CSSTransitionConfig &config,
-    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
-    : shadowNode_(std::move(shadowNode)),
-      viewStylesRepository_(viewStylesRepository),
-      properties_(config.properties),
-      settings_(config.settings),
-      styleInterpolator_(TransitionStyleInterpolator(shadowNode_->getComponentName(), viewStylesRepository)),
-      progressProvider_(TransitionProgressProvider()) {
-  updateAllowedDiscreteProperties();
-}
-
-Tag CSSTransition::getViewTag() const {
-  return shadowNode_->getTag();
-}
-
-std::shared_ptr<const ShadowNode> CSSTransition::getShadowNode() const {
-  return shadowNode_;
-}
-
-double CSSTransition::getMinDelay(double timestamp) const {
-  return progressProvider_.getMinDelay(timestamp);
-}
-
-TransitionProgressState CSSTransition::getState() const {
-  return progressProvider_.getState();
-}
-
-folly::dynamic CSSTransition::getCurrentInterpolationStyle() const {
-  return styleInterpolator_.interpolate(shadowNode_, progressProvider_, allowDiscreteProperties_);
-}
-
-TransitionProperties CSSTransition::getProperties() const {
-  return properties_;
-}
-
-PropertyNames CSSTransition::getAllowedProperties(const folly::dynamic &oldProps, const folly::dynamic &newProps) {
-  if (!oldProps.isObject() || !newProps.isObject()) {
-    return {};
-  }
-
-  // If specific properties are set, process only those
-  if (properties_.has_value()) {
-    PropertyNames allowedProps;
-    const auto &properties = properties_.value();
-    allowedProps.reserve(properties.size());
-
-    for (const auto &prop : properties) {
-      if (isAllowedProperty(prop)) {
-        allowedProps.push_back(prop);
-      }
-    }
-
-    return allowedProps;
-  }
-
-  // Process all properties from both old and new props
-  std::unordered_set<std::string> allAllowedProps;
-
-  for (const auto &props : {oldProps, newProps}) {
-    for (const auto &propertyName : props.keys()) {
-      if (isAllowedProperty(propertyName.asString())) {
-        allAllowedProps.insert(propertyName.asString());
-      }
-    }
-  }
-
-  return {allAllowedProps.begin(), allAllowedProps.end()};
-}
-
-void CSSTransition::updateSettings(const PartialCSSTransitionConfig &config) {
-  if (config.properties.has_value()) {
-    updateTransitionProperties(config.properties.value());
-  }
-  if (config.settings.has_value()) {
-    settings_ = config.settings.value();
-    updateAllowedDiscreteProperties();
-  }
-}
-
-folly::dynamic
-CSSTransition::run(const ChangedProps &changedProps, const folly::dynamic &lastUpdateValue, const double timestamp) {
-  progressProvider_.runProgressProviders(
-      timestamp,
-      settings_,
-      changedProps.changedPropertyNames,
-      styleInterpolator_.getReversedPropertyNames(changedProps.newProps));
-  styleInterpolator_.updateInterpolatedProperties(changedProps, lastUpdateValue);
-  return update(timestamp);
-}
-
-folly::dynamic CSSTransition::update(const double timestamp) {
-  progressProvider_.update(timestamp);
-  auto result = styleInterpolator_.interpolate(shadowNode_, progressProvider_, allowDiscreteProperties_);
-  // Remove interpolators for which interpolation has finished
-  // (we won't need them anymore in the current transition)
-  styleInterpolator_.discardFinishedInterpolators(progressProvider_);
-  // And remove finished progress providers after they were used to calculate
-  // the last frame of the transition
-  progressProvider_.discardFinishedProgressProviders();
-  return result;
-}
-
-void CSSTransition::updateTransitionProperties(const TransitionProperties &properties) {
-  properties_ = properties;
-
-  const auto isAllPropertiesTransition = !properties_.has_value();
-  if (isAllPropertiesTransition) {
-    return;
-  }
-
-  const std::unordered_set<std::string> transitionPropertyNames(properties_->begin(), properties_->end());
-
-  styleInterpolator_.discardIrrelevantInterpolators(transitionPropertyNames);
-  progressProvider_.discardIrrelevantProgressProviders(transitionPropertyNames);
-}
-
-void CSSTransition::updateAllowedDiscreteProperties() {
-  allowDiscreteProperties_.clear();
-  for (const auto &[propertyName, propertySettings] : settings_) {
-    if (propertySettings.allowDiscrete) {
-      allowDiscreteProperties_.insert(propertyName);
-    }
-  }
-}
-
-bool CSSTransition::isAllowedProperty(const std::string &propertyName) const {
-  if (!isDiscreteProperty(propertyName, shadowNode_->getComponentName())) {
-    return true;
-  }
-
-  return allowDiscreteProperties_.contains(propertyName) || allowDiscreteProperties_.contains("all");
-}
-
-} // namespace reanimated::css
+#include <reanimated/CSS/core/CSSTransition.h>
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <utility>
+
+namespace reanimated::css {
+
+CSSTransition::CSSTransition(
+    std::shared_ptr<const ShadowNode> shadowNode,
+    const CSSTransitionConfig &config,
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
+    : shadowNode_(std::move(shadowNode)),
+      viewStylesRepository_(viewStylesRepository),
+      properties_(config.properties),
+      settings_(config.settings),
+      styleInterpolator_(TransitionStyleInterpolator(shadowNode_->getComponentName(), viewStylesRepository)),
+      progressProvider_(TransitionProgressProvider()) {
+  updateAllowedDiscreteProperties();
+}
+
+Tag CSSTransition::getViewTag() const {
+  return shadowNode_->getTag();
+}
+
+std::shared_ptr<const ShadowNode> CSSTransition::getShadowNode() const {
+  return shadowNode_;
+}
+
+double CSSTransition::getMinDelay(double timestamp) const {
+  return progressProvider_.getMinDelay(timestamp);
+}
+
+TransitionProgressState CSSTransition::getState() const {
+  return progressProvider_.getState();
+}
+
+folly::dynamic CSSTransition::getCurrentInterpolationStyle() const {
+  return styleInterpolator_.interpolate(shadowNode_, progressProvider_, allowDiscreteProperties_);
+}
+
+TransitionProperties CSSTransition::getProperties() const {
+  return properties_;
+}
+
+PropertyNames CSSTransition::getAllowedProperties(const folly::dynamic &oldProps, const folly::dynamic &newProps) {
+  if (!oldProps.isObject() || !newProps.isObject()) {
+    return {};
+  }
+
+  // If specific properties are set, process only those
+  if (properties_.has_value()) {
+    PropertyNames allowedProps;
+    const auto &properties = properties_.value();
+    allowedProps.reserve(properties.size());
+
+    for (const auto &prop : properties) {
+      if (isAllowedProperty(prop)) {
+        allowedProps.push_back(prop);
+      }
+    }
+
+    return allowedProps;
+  }
+
+  // Process all properties from both old and new props
+  std::unordered_set<std::string> allAllowedProps;
+
+  for (const auto &props : {oldProps, newProps}) {
+    for (const auto &propertyName : props.keys()) {
+      if (isAllowedProperty(propertyName.asString())) {
+        allAllowedProps.insert(propertyName.asString());
+      }
+    }
+  }
+
+  return {allAllowedProps.begin(), allAllowedProps.end()};
+}
+
+void CSSTransition::updateSettings(const PartialCSSTransitionConfig &config) {
+  if (config.properties.has_value()) {
+    updateTransitionProperties(config.properties.value());
+  }
+  if (config.settings.has_value()) {
+    settings_ = config.settings.value();
+    updateAllowedDiscreteProperties();
+  }
+}
+
+folly::dynamic
+CSSTransition::run(const ChangedProps &changedProps, const folly::dynamic &lastUpdateValue, const double timestamp) {
+  progressProvider_.runProgressProviders(
+      timestamp,
+      settings_,
+      changedProps.changedPropertyNames,
+      styleInterpolator_.getReversedPropertyNames(changedProps.newProps));
+  styleInterpolator_.updateInterpolatedProperties(changedProps, lastUpdateValue);
+  return update(timestamp);
+}
+
+folly::dynamic CSSTransition::update(const double timestamp) {
+  progressProvider_.update(timestamp);
+  auto result = styleInterpolator_.interpolate(shadowNode_, progressProvider_, allowDiscreteProperties_);
+  // Remove interpolators for which interpolation has finished
+  // (we won't need them anymore in the current transition)
+  styleInterpolator_.discardFinishedInterpolators(progressProvider_);
+  // And remove finished progress providers after they were used to calculate
+  // the last frame of the transition
+  progressProvider_.discardFinishedProgressProviders();
+  return result;
+}
+
+void CSSTransition::updateTransitionProperties(const TransitionProperties &properties) {
+  properties_ = properties;
+
+  const auto isAllPropertiesTransition = !properties_.has_value();
+  if (isAllPropertiesTransition) {
+    return;
+  }
+
+  const std::unordered_set<std::string> transitionPropertyNames(properties_->begin(), properties_->end());
+
+  styleInterpolator_.discardIrrelevantInterpolators(transitionPropertyNames);
+  progressProvider_.discardIrrelevantProgressProviders(transitionPropertyNames);
+}
+
+void CSSTransition::updateAllowedDiscreteProperties() {
+  allowDiscreteProperties_.clear();
+  for (const auto &[propertyName, propertySettings] : settings_) {
+    if (propertySettings.allowDiscrete) {
+      allowDiscreteProperties_.insert(propertyName);
+    }
+  }
+}
+
+bool CSSTransition::isAllowedProperty(const std::string &propertyName) const {
+  if (!isDiscreteProperty(propertyName, shadowNode_->getComponentName())) {
+    return true;
+  }
+
+  return allowDiscreteProperties_.contains(propertyName) || allowDiscreteProperties_.contains("all");
+}
+
+} // namespace reanimated::css

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

@@ -1,47 +1,47 @@
-#pragma once
-
-#include <reanimated/CSS/configs/CSSTransitionConfig.h>
-#include <reanimated/CSS/easing/EasingFunctions.h>
-#include <reanimated/CSS/interpolation/styles/TransitionStyleInterpolator.h>
-#include <reanimated/CSS/progress/TransitionProgressProvider.h>
-
-#include <memory>
-#include <string>
-#include <unordered_set>
-
-namespace reanimated::css {
-
-class CSSTransition {
- public:
-  CSSTransition(
-      std::shared_ptr<const ShadowNode> shadowNode,
-      const CSSTransitionConfig &config,
-      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
-
-  Tag getViewTag() const;
-  std::shared_ptr<const ShadowNode> getShadowNode() const;
-  double getMinDelay(double timestamp) const;
-  TransitionProgressState getState() const;
-  folly::dynamic getCurrentInterpolationStyle() const;
-  TransitionProperties getProperties() const;
-  PropertyNames getAllowedProperties(const folly::dynamic &oldProps, const folly::dynamic &newProps);
-
-  void updateSettings(const PartialCSSTransitionConfig &config);
-  folly::dynamic run(const ChangedProps &changedProps, const folly::dynamic &lastUpdateValue, double timestamp);
-  folly::dynamic update(double timestamp);
-
- private:
-  const std::shared_ptr<const ShadowNode> shadowNode_;
-  const std::shared_ptr<ViewStylesRepository> viewStylesRepository_;
-  std::unordered_set<std::string> allowDiscreteProperties_;
-  TransitionProperties properties_;
-  CSSTransitionPropertiesSettings settings_;
-  TransitionStyleInterpolator styleInterpolator_;
-  TransitionProgressProvider progressProvider_;
-
-  void updateTransitionProperties(const TransitionProperties &properties);
-  void updateAllowedDiscreteProperties();
-  bool isAllowedProperty(const std::string &propertyName) const;
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/configs/CSSTransitionConfig.h>
+#include <reanimated/CSS/easing/EasingFunctions.h>
+#include <reanimated/CSS/interpolation/styles/TransitionStyleInterpolator.h>
+#include <reanimated/CSS/progress/TransitionProgressProvider.h>
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+
+namespace reanimated::css {
+
+class CSSTransition {
+ public:
+  CSSTransition(
+      std::shared_ptr<const ShadowNode> shadowNode,
+      const CSSTransitionConfig &config,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
+
+  Tag getViewTag() const;
+  std::shared_ptr<const ShadowNode> getShadowNode() const;
+  double getMinDelay(double timestamp) const;
+  TransitionProgressState getState() const;
+  folly::dynamic getCurrentInterpolationStyle() const;
+  TransitionProperties getProperties() const;
+  PropertyNames getAllowedProperties(const folly::dynamic &oldProps, const folly::dynamic &newProps);
+
+  void updateSettings(const PartialCSSTransitionConfig &config);
+  folly::dynamic run(const ChangedProps &changedProps, const folly::dynamic &lastUpdateValue, double timestamp);
+  folly::dynamic update(double timestamp);
+
+ private:
+  const std::shared_ptr<const ShadowNode> shadowNode_;
+  const std::shared_ptr<ViewStylesRepository> viewStylesRepository_;
+  std::unordered_set<std::string> allowDiscreteProperties_;
+  TransitionProperties properties_;
+  CSSTransitionPropertiesSettings settings_;
+  TransitionStyleInterpolator styleInterpolator_;
+  TransitionProgressProvider progressProvider_;
+
+  void updateTransitionProperties(const TransitionProperties &properties);
+  void updateAllowedDiscreteProperties();
+  bool isAllowedProperty(const std::string &propertyName) const;
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/easing/EasingFunctions.cpp

@@ -1,69 +1,69 @@
-#include <reanimated/CSS/easing/EasingFunctions.h>
-
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-namespace reanimated::css {
-
-inline const std::unordered_map<std::string, EasingFunction> PREDEFINED_EASING_MAP = {
-    {"linear",
-     [](double x) {
-       return x;
-     }},
-    {"ease", cubicBezier(0.25, 0.1, 0.25, 0.1)},
-    {"ease-in", cubicBezier(0.42, 0.0, 1.0, 1.0)},
-    {"ease-out", cubicBezier(0.0, 0.0, 0.58, 1.0)},
-    {"ease-in-out", cubicBezier(0.42, 0.0, 0.58, 1.0)},
-    {"step-start", steps(std::vector<double>{0}, std::vector<double>{1})},
-    {"step-end", steps(std::vector<double>{0, 1}, std::vector<double>{0, 1})}};
-
-EasingFunction createEasingFunction(jsi::Runtime &rt, const jsi::Value &easingConfig) {
-  if (easingConfig.isString()) {
-    return getPredefinedEasingFunction(easingConfig.asString(rt).utf8(rt));
-  } else if (easingConfig.isObject()) {
-    return createParametrizedEasingFunction(rt, easingConfig.asObject(rt));
-  } else {
-    throw std::runtime_error(std::string("[Reanimated] Invalid easing function"));
-  }
-}
-
-EasingFunction getPredefinedEasingFunction(const std::string &name) {
-  auto it = PREDEFINED_EASING_MAP.find(name);
-  if (it != PREDEFINED_EASING_MAP.end()) {
-    return it->second;
-  } else {
-    throw std::runtime_error(std::string("[Reanimated] Easing function with name '" + name + "' is not defined."));
-  }
-}
-
-EasingFunction createParametrizedEasingFunction(jsi::Runtime &rt, const jsi::Object &easingConfig) {
-  const auto easingName = easingConfig.getProperty(rt, "name").asString(rt).utf8(rt);
-
-  if (easingName == "cubicBezier") {
-    return cubicBezier(rt, easingConfig);
-  }
-
-  std::vector<double> pointsX;
-  std::vector<double> pointsY;
-
-  const auto points = easingConfig.getProperty(rt, "points").asObject(rt).asArray(rt);
-  const auto pointsCount = points.size(rt);
-
-  for (size_t i = 0; i < pointsCount; i++) {
-    const auto pointObj = points.getValueAtIndex(rt, i).asObject(rt);
-    pointsX.push_back(pointObj.getProperty(rt, "x").asNumber());
-    pointsY.push_back(pointObj.getProperty(rt, "y").asNumber());
-  }
-
-  if (easingName == "linear") {
-    return linear(pointsX, pointsY);
-  } else if (easingName == "steps") {
-    return steps(pointsX, pointsY);
-  } else {
-    throw std::runtime_error(
-        std::string("[Reanimated] Parametrized easing function with name '" + easingName + "' is not defined."));
-  }
-}
-
-} // namespace reanimated::css
+#include <reanimated/CSS/easing/EasingFunctions.h>
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace reanimated::css {
+
+inline const std::unordered_map<std::string, EasingFunction> PREDEFINED_EASING_MAP = {
+    {"linear",
+     [](double x) {
+       return x;
+     }},
+    {"ease", cubicBezier(0.25, 0.1, 0.25, 0.1)},
+    {"ease-in", cubicBezier(0.42, 0.0, 1.0, 1.0)},
+    {"ease-out", cubicBezier(0.0, 0.0, 0.58, 1.0)},
+    {"ease-in-out", cubicBezier(0.42, 0.0, 0.58, 1.0)},
+    {"step-start", steps(std::vector<double>{0}, std::vector<double>{1})},
+    {"step-end", steps(std::vector<double>{0, 1}, std::vector<double>{0, 1})}};
+
+EasingFunction createEasingFunction(jsi::Runtime &rt, const jsi::Value &easingConfig) {
+  if (easingConfig.isString()) {
+    return getPredefinedEasingFunction(easingConfig.asString(rt).utf8(rt));
+  } else if (easingConfig.isObject()) {
+    return createParametrizedEasingFunction(rt, easingConfig.asObject(rt));
+  } else {
+    throw std::runtime_error(std::string("[Reanimated] Invalid easing function"));
+  }
+}
+
+EasingFunction getPredefinedEasingFunction(const std::string &name) {
+  auto it = PREDEFINED_EASING_MAP.find(name);
+  if (it != PREDEFINED_EASING_MAP.end()) {
+    return it->second;
+  } else {
+    throw std::runtime_error(std::string("[Reanimated] Easing function with name '" + name + "' is not defined."));
+  }
+}
+
+EasingFunction createParametrizedEasingFunction(jsi::Runtime &rt, const jsi::Object &easingConfig) {
+  const auto easingName = easingConfig.getProperty(rt, "name").asString(rt).utf8(rt);
+
+  if (easingName == "cubicBezier") {
+    return cubicBezier(rt, easingConfig);
+  }
+
+  std::vector<double> pointsX;
+  std::vector<double> pointsY;
+
+  const auto points = easingConfig.getProperty(rt, "points").asObject(rt).asArray(rt);
+  const auto pointsCount = points.size(rt);
+
+  for (size_t i = 0; i < pointsCount; i++) {
+    const auto pointObj = points.getValueAtIndex(rt, i).asObject(rt);
+    pointsX.push_back(pointObj.getProperty(rt, "x").asNumber());
+    pointsY.push_back(pointObj.getProperty(rt, "y").asNumber());
+  }
+
+  if (easingName == "linear") {
+    return linear(pointsX, pointsY);
+  } else if (easingName == "steps") {
+    return steps(pointsX, pointsY);
+  } else {
+    throw std::runtime_error(
+        std::string("[Reanimated] Parametrized easing function with name '" + easingName + "' is not defined."));
+  }
+}
+
+} // namespace reanimated::css