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

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

@@ -1,174 +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
+#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

@@ -1,49 +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
+#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

@@ -1,45 +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
+#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

@@ -1,26 +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
+#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