@react-native-ohos/react-native-reanimated 3.18.2-rc.2 → 4.0.0-rc.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/common/values/complex/CSSDropShadow.cpp

@@ -0,0 +1,134 @@
+#include <reanimated/CSS/common/values/complex/CSSDropShadow.h>
+
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace reanimated::css {
+
+CSSDropShadow::CSSDropShadow(CSSDouble offsetX, CSSDouble offsetY, CSSDouble standardDeviation, CSSColor color)
+    : offsetX(std::move(offsetX)),
+      offsetY(std::move(offsetY)),
+      standardDeviation(std::move(standardDeviation)),
+      color(std::move(color)) {}
+
+CSSDropShadow::CSSDropShadow(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  const auto &obj = jsiValue.asObject(rt);
+
+  if (obj.hasProperty(rt, "offsetX")) {
+    offsetX = CSSDouble(rt, obj.getProperty(rt, "offsetX"));
+  }
+  if (obj.hasProperty(rt, "offsetY")) {
+    offsetY = CSSDouble(rt, obj.getProperty(rt, "offsetY"));
+  }
+  if (obj.hasProperty(rt, "standardDeviation")) {
+    standardDeviation = CSSDouble(rt, obj.getProperty(rt, "standardDeviation"));
+  }
+  if (obj.hasProperty(rt, "color")) {
+    color = CSSColor(rt, obj.getProperty(rt, "color"));
+  }
+}
+
+CSSDropShadow::CSSDropShadow(const folly::dynamic &value) {
+  if (value.count("offsetX") > 0) {
+    offsetX = CSSDouble(value["offsetX"]);
+  }
+  if (value.count("offsetY") > 0) {
+    offsetY = CSSDouble(value["offsetY"]);
+  }
+  if (value.count("standardDeviation") > 0) {
+    standardDeviation = CSSDouble(value["standardDeviation"]);
+  }
+  if (value.count("color") > 0) {
+    color = CSSColor(value["color"]);
+  }
+}
+
+bool CSSDropShadow::canConstruct(const folly::dynamic &value) {
+  if (!value.isObject()) {
+    return false;
+  }
+
+  for (const auto &validator : fieldValidators) {
+    if (value.count(validator.fieldName) > 0 && !validator.validateDynamic(value[validator.fieldName])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool CSSDropShadow::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  if (!jsiValue.isObject()) {
+    return false;
+  }
+
+  const auto &obj = jsiValue.asObject(rt);
+
+  for (const auto &validator : fieldValidators) {
+    const auto &fieldName = validator.fieldName.c_str();
+    if (obj.hasProperty(rt, fieldName) && !validator.validateJSI(rt, obj.getProperty(rt, fieldName))) {
+      return false;
+    }
+  }
+  return true;
+}
+folly::dynamic CSSDropShadow::toDynamic() const {
+  folly::dynamic obj = folly::dynamic::object();
+
+  obj["offsetX"] = offsetX.toDynamic();
+  obj["offsetY"] = offsetY.toDynamic();
+  obj["standardDeviation"] = standardDeviation.toDynamic();
+  obj["color"] = color.toDynamic();
+  return obj;
+}
+std::string CSSDropShadow::toString() const {
+  return "drop-shadow(" + offsetX.toString() + " " + offsetY.toString() + " " + standardDeviation.toString() + " " +
+      color.toString() + ")";
+}
+
+CSSDropShadow CSSDropShadow::interpolate(double progress, const CSSDropShadow &to) const {
+  return CSSDropShadow(
+      offsetX.interpolate(progress, to.offsetX),
+      offsetY.interpolate(progress, to.offsetY),
+      standardDeviation.interpolate(progress, to.standardDeviation),
+      color.interpolate(progress, to.color));
+}
+
+bool CSSDropShadow::operator==(const CSSDropShadow &other) const {
+  return offsetX == other.offsetX && offsetY == other.offsetY && standardDeviation == other.standardDeviation &&
+      color == other.color;
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const CSSDropShadow &shadowValue) {
+  os << "CSSDropShadow(" << shadowValue.toString() << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+const std::vector<FieldValidator> CSSDropShadow::fieldValidators = {
+    {"offsetX",
+     [](const folly::dynamic &value) { return CSSDouble::canConstruct(value); },
+     [](jsi::Runtime &rt, const jsi::Value &jsiValue) {
+       return CSSDouble::canConstruct(rt, jsiValue);
+     }},
+    {"offsetY",
+     [](const folly::dynamic &value) { return CSSDouble::canConstruct(value); },
+     [](jsi::Runtime &rt, const jsi::Value &jsiValue) {
+       return CSSDouble::canConstruct(rt, jsiValue);
+     }},
+    {"standardDeviation",
+     [](const folly::dynamic &value) { return CSSDouble::canConstruct(value); },
+     [](jsi::Runtime &rt, const jsi::Value &jsiValue) {
+       return CSSDouble::canConstruct(rt, jsiValue);
+     }},
+    {"color",
+     [](const folly::dynamic &value) { return CSSColor::canConstruct(value); },
+     [](jsi::Runtime &rt, const jsi::Value &jsiValue) {
+       return CSSColor::canConstruct(rt, jsiValue);
+     }},
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/common/values/complex/CSSDropShadow.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <reanimated/CSS/common/definitions.h>
+#include <reanimated/CSS/common/values/CSSBoolean.h>
+#include <reanimated/CSS/common/values/CSSColor.h>
+#include <reanimated/CSS/common/values/CSSNumber.h>
+
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace reanimated::css {
+
+struct CSSDropShadow : public CSSSimpleValue<CSSDropShadow> {
+  CSSDouble offsetX;
+  CSSDouble offsetY;
+  CSSDouble standardDeviation;
+  CSSColor color;
+
+  CSSDropShadow() = default;
+
+  explicit CSSDropShadow(CSSDouble offsetX, CSSDouble offsetY, CSSDouble standardDeviation, CSSColor color);
+  explicit CSSDropShadow(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  explicit CSSDropShadow(const folly::dynamic &value);
+
+  static bool canConstruct(const folly::dynamic &value);
+  static bool canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue);
+
+  folly::dynamic toDynamic() const;
+  std::string toString() const;
+
+  CSSDropShadow interpolate(double progress, const CSSDropShadow &to) const;
+
+  bool operator==(const CSSDropShadow &other) const;
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const CSSDropShadow &shadowValue);
+#endif // NDEBUG
+
+ private:
+  static const std::vector<FieldValidator> fieldValidators;
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,174 @@
+#include <reanimated/CSS/configs/CSSAnimationConfig.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace reanimated::css {
+
+double getIterationCount(jsi::Runtime &rt, const jsi::Object &settings) {
+  return settings.getProperty(rt, "iterationCount").asNumber();
+}
+
+AnimationDirection getDirection(jsi::Runtime &rt, const jsi::Object &settings) {
+  static const std::unordered_map<std::string, AnimationDirection> strToEnumMap = {
+      {"normal", AnimationDirection::Normal},
+      {"reverse", AnimationDirection::Reverse},
+      {"alternate", AnimationDirection::Alternate},
+      {"alternate-reverse", AnimationDirection::AlternateReverse}};
+
+  const auto str = settings.getProperty(rt, "direction").asString(rt).utf8(rt);
+  auto it = strToEnumMap.find(str);
+  if (it == strToEnumMap.cend()) {
+    throw std::invalid_argument("[Reanimated] Invalid animationDirection: " + str);
+  }
+  return it->second;
+}
+
+AnimationFillMode getFillMode(jsi::Runtime &rt, const jsi::Object &settings) {
+  static const std::unordered_map<std::string, AnimationFillMode> strToEnumMap = {
+      {"none", AnimationFillMode::None},
+      {"forwards", AnimationFillMode::Forwards},
+      {"backwards", AnimationFillMode::Backwards},
+      {"both", AnimationFillMode::Both}};
+
+  const auto str = settings.getProperty(rt, "fillMode").asString(rt).utf8(rt);
+  auto it = strToEnumMap.find(str);
+  if (it == strToEnumMap.cend()) {
+    throw std::invalid_argument("[Reanimated] Invalid animationFillMode: " + str);
+  }
+  return it->second;
+}
+
+AnimationPlayState getPlayState(jsi::Runtime &rt, const jsi::Object &settings) {
+  static const std::unordered_map<std::string, AnimationPlayState> strToEnumMap = {
+      {"running", AnimationPlayState::Running}, {"paused", AnimationPlayState::Paused}};
+
+  const auto str = settings.getProperty(rt, "playState").asString(rt).utf8(rt);
+  auto it = strToEnumMap.find(str);
+  if (it == strToEnumMap.cend()) {
+    throw std::invalid_argument("[Reanimated] Invalid animationPlayState: " + str);
+  }
+  return it->second;
+}
+
+CSSAnimationSettings parseCSSAnimationSettings(jsi::Runtime &rt, const jsi::Value &settings) {
+  const auto &settingsObj = settings.asObject(rt);
+
+  return {
+      getDuration(rt, settingsObj),
+      getTimingFunction(rt, settingsObj),
+      getDelay(rt, settingsObj),
+      getIterationCount(rt, settingsObj),
+      getDirection(rt, settingsObj),
+      getFillMode(rt, settingsObj),
+      getPlayState(rt, settingsObj)};
+}
+
+PartialCSSAnimationSettings parsePartialCSSAnimationSettings(jsi::Runtime &rt, const jsi::Value &partialSettings) {
+  const auto &partialObj = partialSettings.asObject(rt);
+
+  PartialCSSAnimationSettings result;
+
+  if (partialObj.hasProperty(rt, "duration")) {
+    result.duration = getDuration(rt, partialObj);
+  }
+  if (partialObj.hasProperty(rt, "timingFunction")) {
+    result.easingFunction = getTimingFunction(rt, partialObj);
+  }
+  if (partialObj.hasProperty(rt, "delay")) {
+    result.delay = getDelay(rt, partialObj);
+  }
+  if (partialObj.hasProperty(rt, "iterationCount")) {
+    result.iterationCount = getIterationCount(rt, partialObj);
+  }
+  if (partialObj.hasProperty(rt, "direction")) {
+    result.direction = getDirection(rt, partialObj);
+  }
+  if (partialObj.hasProperty(rt, "fillMode")) {
+    result.fillMode = getFillMode(rt, partialObj);
+  }
+  if (partialObj.hasProperty(rt, "playState")) {
+    result.playState = getPlayState(rt, partialObj);
+  }
+
+  return result;
+}
+
+std::vector<std::string> parseAnimationNames(jsi::Runtime &rt, const jsi::Value &animationNames) {
+  std::vector<std::string> result;
+
+  const auto &namesArray = animationNames.asObject(rt).asArray(rt);
+  const auto animationNamesCount = namesArray.size(rt);
+  result.reserve(animationNamesCount);
+
+  for (size_t i = 0; i < animationNamesCount; i++) {
+    result.emplace_back(namesArray.getValueAtIndex(rt, i).asString(rt).utf8(rt));
+  }
+
+  return result;
+}
+
+template <typename TResult>
+std::unordered_map<size_t, TResult> parseHelper(
+    jsi::Runtime &rt,
+    const jsi::Object &settingsObj,
+    const std::function<TResult(jsi::Runtime &, const jsi::Value &)> &parseFunction) {
+  std::unordered_map<size_t, TResult> result;
+
+  const auto animationIndices = settingsObj.getPropertyNames(rt);
+  const auto animationIndicesCount = animationIndices.size(rt);
+  result.reserve(animationIndicesCount);
+
+  for (size_t i = 0; i < animationIndicesCount; i++) {
+    const auto &indexStr = animationIndices.getValueAtIndex(rt, i).toString(rt);
+    const auto &animationSettings = settingsObj.getProperty(rt, indexStr);
+
+    const auto index = std::stoul(indexStr.utf8(rt));
+    result[index] = parseFunction(rt, animationSettings);
+  }
+
+  return result;
+}
+
+CSSAnimationSettingsMap parseNewAnimationSettings(
+    jsi::Runtime &rt,
+    const std::vector<std::string> &animationNames,
+    const jsi::Value &newSettings) {
+  return parseHelper<CSSAnimationSettings>(
+      rt, newSettings.asObject(rt), [&](jsi::Runtime &rt, const jsi::Value &settings) {
+        return parseCSSAnimationSettings(rt, settings);
+      });
+}
+
+CSSAnimationSettingsUpdatesMap parseSettingsUpdates(jsi::Runtime &rt, const jsi::Value &settingsUpdates) {
+  return parseHelper<PartialCSSAnimationSettings>(
+      rt, settingsUpdates.asObject(rt), [](jsi::Runtime &rt, const jsi::Value &settings) {
+        return parsePartialCSSAnimationSettings(rt, settings);
+      });
+}
+
+CSSAnimationUpdates parseCSSAnimationUpdates(jsi::Runtime &rt, const jsi::Value &config) {
+  const auto &configObj = config.asObject(rt);
+
+  CSSAnimationUpdates result;
+
+  if (configObj.hasProperty(rt, "animationNames")) {
+    result.animationNames = parseAnimationNames(rt, configObj.getProperty(rt, "animationNames"));
+
+    if (configObj.hasProperty(rt, "newAnimationSettings")) {
+      result.newAnimationSettings = parseNewAnimationSettings(
+          rt, result.animationNames.value(), configObj.getProperty(rt, "newAnimationSettings"));
+    }
+  }
+
+  if (configObj.hasProperty(rt, "settingsUpdates")) {
+    result.settingsUpdates = parseSettingsUpdates(rt, configObj.getProperty(rt, "settingsUpdates"));
+  }
+
+  return result;
+}
+
+} // namespace reanimated::css

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

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <reanimated/CSS/configs/CSSKeyframesConfig.h>
+#include <reanimated/CSS/configs/common.h>
+#include <reanimated/CSS/easing/EasingFunctions.h>
+
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace reanimated::css {
+
+enum class AnimationDirection : std::uint8_t { Normal, Reverse, Alternate, AlternateReverse };
+enum class AnimationFillMode : std::uint8_t { None, Forwards, Backwards, Both };
+enum class AnimationPlayState : std::uint8_t { Running, Paused };
+
+struct CSSAnimationSettings {
+  double duration;
+  EasingFunction easingFunction;
+  double delay;
+  double iterationCount;
+  AnimationDirection direction;
+  AnimationFillMode fillMode;
+  AnimationPlayState playState;
+};
+
+struct PartialCSSAnimationSettings {
+  std::optional<double> duration;
+  std::optional<EasingFunction> easingFunction;
+  std::optional<double> delay;
+  std::optional<double> iterationCount;
+  std::optional<AnimationDirection> direction;
+  std::optional<AnimationFillMode> fillMode;
+  std::optional<AnimationPlayState> playState;
+};
+
+using CSSAnimationSettingsMap = std::unordered_map<size_t, CSSAnimationSettings>;
+using CSSAnimationSettingsUpdatesMap = std::unordered_map<size_t, PartialCSSAnimationSettings>;
+
+struct CSSAnimationUpdates {
+  std::optional<std::vector<std::string>> animationNames;
+  CSSAnimationSettingsMap newAnimationSettings;
+  CSSAnimationSettingsUpdatesMap settingsUpdates;
+};
+
+CSSAnimationUpdates parseCSSAnimationUpdates(jsi::Runtime &rt, const jsi::Value &config);
+
+} // namespace reanimated::css

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

@@ -0,0 +1,45 @@
+#include <reanimated/CSS/configs/CSSKeyframesConfig.h>
+
+#include <memory>
+#include <string>
+
+namespace reanimated::css {
+
+std::shared_ptr<AnimationStyleInterpolator> createStyleInterpolator(
+    jsi::Runtime &rt,
+    const jsi::Object &config,
+    const std::string &componentName,
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository) {
+  return std::make_shared<AnimationStyleInterpolator>(
+      rt, config.getProperty(rt, "keyframesStyle"), componentName, viewStylesRepository);
+}
+
+std::shared_ptr<KeyframeEasingFunctions> getKeyframeTimingFunctions(jsi::Runtime &rt, const jsi::Object &config) {
+  KeyframeEasingFunctions result;
+  const auto &keyframeTimingFunctions = config.getProperty(rt, "keyframeTimingFunctions").asObject(rt);
+  const auto timingFunctionOffsets = keyframeTimingFunctions.getPropertyNames(rt);
+  const auto timingFunctionsCount = timingFunctionOffsets.size(rt);
+
+  for (size_t i = 0; i < timingFunctionsCount; ++i) {
+    const auto offset = timingFunctionOffsets.getValueAtIndex(rt, i).asString(rt).utf8(rt);
+    const auto easingFunction = createEasingFunction(rt, keyframeTimingFunctions.getProperty(rt, offset.c_str()));
+
+    result[std::stod(offset)] = easingFunction;
+  }
+
+  return std::make_shared<KeyframeEasingFunctions>(result);
+}
+
+CSSKeyframesConfig parseCSSAnimationKeyframesConfig(
+    jsi::Runtime &rt,
+    const jsi::Value &config,
+    const std::string &componentName,
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository) {
+  const auto &configObj = config.asObject(rt);
+
+  return {
+      createStyleInterpolator(rt, configObj, componentName, viewStylesRepository),
+      getKeyframeTimingFunctions(rt, configObj)};
+}
+
+} // namespace reanimated::css

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <reanimated/CSS/easing/EasingFunctions.h>
+#include <reanimated/CSS/interpolation/styles/AnimationStyleInterpolator.h>
+#include <reanimated/CSS/misc/ViewStylesRepository.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace reanimated::css {
+
+using KeyframeEasingFunctions = std::unordered_map<double, EasingFunction>;
+
+struct CSSKeyframesConfig {
+  std::shared_ptr<AnimationStyleInterpolator> styleInterpolator;
+  std::shared_ptr<KeyframeEasingFunctions> keyframeEasingFunctions;
+};
+
+CSSKeyframesConfig parseCSSAnimationKeyframesConfig(
+    jsi::Runtime &rt,
+    const jsi::Value &config,
+    const std::string &componentName,
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
+
+} // namespace reanimated::css

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

@@ -0,0 +1,90 @@
+#include <reanimated/CSS/configs/CSSTransitionConfig.h>
+
+#include <string>
+
+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);
+  const auto propertiesCount = propertyNames.size(rt);
+
+  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);
+
+    result.emplace(
+        propertyName,
+        CSSTransitionPropertySettings{
+            getDuration(rt, propertySettings),
+            getTimingFunction(rt, propertySettings),
+            getDelay(rt, propertySettings),
+            getAllowDiscrete(rt, propertySettings)});
+  }
+
+  return result;
+}
+
+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))};
+}
+
+PartialCSSTransitionConfig parsePartialCSSTransitionConfig(jsi::Runtime &rt, const jsi::Value &partialConfig) {
+  const auto partialObj = partialConfig.asObject(rt);
+
+  PartialCSSTransitionConfig result;
+
+  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));
+  }
+
+  return result;
+}
+
+} // namespace reanimated::css

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

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <reanimated/CSS/common/definitions.h>
+#include <reanimated/CSS/configs/common.h>
+#include <reanimated/CSS/easing/EasingFunctions.h>
+
+#include <string>
+#include <unordered_map>
+
+namespace reanimated::css {
+
+struct CSSTransitionPropertySettings {
+  double duration;
+  EasingFunction easingFunction;
+  double delay;
+  bool allowDiscrete;
+};
+
+using CSSTransitionPropertiesSettings = std::unordered_map<std::string, CSSTransitionPropertySettings>;
+
+struct CSSTransitionConfig {
+  TransitionProperties properties;
+  CSSTransitionPropertiesSettings settings;
+};
+
+struct PartialCSSTransitionConfig {
+  std::optional<TransitionProperties> properties;
+  std::optional<CSSTransitionPropertiesSettings> settings;
+};
+
+std::optional<CSSTransitionPropertySettings> getTransitionPropertySettings(
+    const CSSTransitionPropertiesSettings &propertiesSettings,
+    const std::string &propName);
+
+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);
+
+PartialCSSTransitionConfig parsePartialCSSTransitionConfig(jsi::Runtime &rt, const jsi::Value &partialConfig);
+
+} // namespace reanimated::css

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

@@ -0,0 +1,17 @@
+#include <reanimated/CSS/configs/common.h>
+
+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"));
+}
+
+double getDelay(jsi::Runtime &rt, const jsi::Object &config) {
+  return config.getProperty(rt, "delay").asNumber();
+}
+
+} // namespace reanimated::css

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

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <reanimated/CSS/easing/EasingFunctions.h>
+
+namespace reanimated::css {
+
+double getDuration(jsi::Runtime &rt, const jsi::Object &config);
+
+EasingFunction getTimingFunction(jsi::Runtime &rt, const jsi::Object &config);
+
+double getDelay(jsi::Runtime &rt, const jsi::Object &config);
+
+} // namespace reanimated::css