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

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/values/SimpleValueInterpolator.cpp

@@ -1,70 +1,70 @@
-#include <reanimated/CSS/interpolation/values/SimpleValueInterpolator.h>
-
-#include <folly/dynamic.h>
-#include <jsi/jsi.h>
-
-#include <reanimated/CSS/common/values/CSSAngle.h>
-#include <reanimated/CSS/common/values/CSSBoolean.h>
-#include <reanimated/CSS/common/values/CSSColor.h>
-#include <reanimated/CSS/common/values/CSSDiscreteArray.h>
-#include <reanimated/CSS/common/values/CSSKeyword.h>
-#include <reanimated/CSS/common/values/CSSLength.h>
-#include <reanimated/CSS/common/values/CSSNumber.h>
-#include <reanimated/CSS/common/values/complex/CSSBoxShadow.h>
-#include <reanimated/CSS/svg/values/SVGBrush.h>
-#include <reanimated/CSS/svg/values/SVGLength.h>
-#include <reanimated/CSS/svg/values/SVGStrokeDashArray.h>
-
-#include <memory>
-
-namespace reanimated::css {
-
-template <typename... AllowedTypes>
-SimpleValueInterpolator<AllowedTypes...>::SimpleValueInterpolator(
-    const PropertyPath &propertyPath,
-    const ValueType &defaultStyleValue,
-    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
-    : ValueInterpolator(propertyPath, std::make_shared<ValueType>(defaultStyleValue), viewStylesRepository) {}
-
-template <typename... AllowedTypes>
-std::shared_ptr<CSSValue> SimpleValueInterpolator<AllowedTypes...>::createValue(
-    jsi::Runtime &rt,
-    const jsi::Value &value) const {
-  return std::make_shared<ValueType>(rt, value);
-}
-
-template <typename... AllowedTypes>
-std::shared_ptr<CSSValue> SimpleValueInterpolator<AllowedTypes...>::createValue(const folly::dynamic &value) const {
-  return std::make_shared<ValueType>(value);
-}
-
-template <typename... AllowedTypes>
-folly::dynamic SimpleValueInterpolator<AllowedTypes...>::interpolateValue(
-    double progress,
-    const std::shared_ptr<CSSValue> &fromValue,
-    const std::shared_ptr<CSSValue> &toValue,
-    const ValueInterpolationContext &context) const {
-  const auto &from = std::static_pointer_cast<ValueType>(fromValue);
-  const auto &to = std::static_pointer_cast<ValueType>(toValue);
-  return from->interpolate(progress, *to, context).toDynamic();
-}
-
-template class SimpleValueInterpolator<CSSLength>;
-template class SimpleValueInterpolator<CSSLength, CSSKeyword>;
-template class SimpleValueInterpolator<CSSDouble>;
-template class SimpleValueInterpolator<CSSDouble, CSSKeyword>;
-template class SimpleValueInterpolator<CSSInteger>;
-template class SimpleValueInterpolator<CSSAngle>;
-template class SimpleValueInterpolator<CSSColor>;
-template class SimpleValueInterpolator<CSSBoolean>;
-template class SimpleValueInterpolator<CSSDisplay>;
-template class SimpleValueInterpolator<CSSKeyword>;
-template class SimpleValueInterpolator<CSSBoxShadow>;
-template class SimpleValueInterpolator<CSSDiscreteArray<CSSKeyword>>;
-
-template class SimpleValueInterpolator<SVGLength>;
-template class SimpleValueInterpolator<SVGLength, CSSKeyword>;
-template class SimpleValueInterpolator<SVGStrokeDashArray, CSSKeyword>;
-template class SimpleValueInterpolator<SVGBrush>;
-
-} // namespace reanimated::css
+#include <reanimated/CSS/interpolation/values/SimpleValueInterpolator.h>
+
+#include <folly/dynamic.h>
+#include <jsi/jsi.h>
+
+#include <reanimated/CSS/common/values/CSSAngle.h>
+#include <reanimated/CSS/common/values/CSSBoolean.h>
+#include <reanimated/CSS/common/values/CSSColor.h>
+#include <reanimated/CSS/common/values/CSSDiscreteArray.h>
+#include <reanimated/CSS/common/values/CSSKeyword.h>
+#include <reanimated/CSS/common/values/CSSLength.h>
+#include <reanimated/CSS/common/values/CSSNumber.h>
+#include <reanimated/CSS/common/values/complex/CSSBoxShadow.h>
+#include <reanimated/CSS/svg/values/SVGBrush.h>
+#include <reanimated/CSS/svg/values/SVGLength.h>
+#include <reanimated/CSS/svg/values/SVGStrokeDashArray.h>
+
+#include <memory>
+
+namespace reanimated::css {
+
+template <typename... AllowedTypes>
+SimpleValueInterpolator<AllowedTypes...>::SimpleValueInterpolator(
+    const PropertyPath &propertyPath,
+    const ValueType &defaultStyleValue,
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
+    : ValueInterpolator(propertyPath, std::make_shared<ValueType>(defaultStyleValue), viewStylesRepository) {}
+
+template <typename... AllowedTypes>
+std::shared_ptr<CSSValue> SimpleValueInterpolator<AllowedTypes...>::createValue(
+    jsi::Runtime &rt,
+    const jsi::Value &value) const {
+  return std::make_shared<ValueType>(rt, value);
+}
+
+template <typename... AllowedTypes>
+std::shared_ptr<CSSValue> SimpleValueInterpolator<AllowedTypes...>::createValue(const folly::dynamic &value) const {
+  return std::make_shared<ValueType>(value);
+}
+
+template <typename... AllowedTypes>
+folly::dynamic SimpleValueInterpolator<AllowedTypes...>::interpolateValue(
+    double progress,
+    const std::shared_ptr<CSSValue> &fromValue,
+    const std::shared_ptr<CSSValue> &toValue,
+    const ValueInterpolationContext &context) const {
+  const auto &from = std::static_pointer_cast<ValueType>(fromValue);
+  const auto &to = std::static_pointer_cast<ValueType>(toValue);
+  return from->interpolate(progress, *to, context).toDynamic();
+}
+
+template class SimpleValueInterpolator<CSSLength>;
+template class SimpleValueInterpolator<CSSLength, CSSKeyword>;
+template class SimpleValueInterpolator<CSSDouble>;
+template class SimpleValueInterpolator<CSSDouble, CSSKeyword>;
+template class SimpleValueInterpolator<CSSInteger>;
+template class SimpleValueInterpolator<CSSAngle>;
+template class SimpleValueInterpolator<CSSColor>;
+template class SimpleValueInterpolator<CSSBoolean>;
+template class SimpleValueInterpolator<CSSDisplay>;
+template class SimpleValueInterpolator<CSSKeyword>;
+template class SimpleValueInterpolator<CSSBoxShadow>;
+template class SimpleValueInterpolator<CSSDiscreteArray<CSSKeyword>>;
+
+template class SimpleValueInterpolator<SVGLength>;
+template class SimpleValueInterpolator<SVGLength, CSSKeyword>;
+template class SimpleValueInterpolator<SVGStrokeDashArray, CSSKeyword>;
+template class SimpleValueInterpolator<SVGBrush>;
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/values/SimpleValueInterpolator.h

@@ -1,40 +1,40 @@
-#pragma once
-
-#include <reanimated/CSS/interpolation/values/ValueInterpolator.h>
-
-#include <memory>
-
-namespace reanimated::css {
-
-/**
- * Concrete implementation of ValueInterpolator for simple CSS values that don't
- * require resolution before interpolation. This class handles direct
- * interpolation between values without any additional processing or resolution.
- */
-template <typename... AllowedTypes>
-class SimpleValueInterpolator : public ValueInterpolator {
-  static_assert(
-      (... && std::is_base_of<CSSValue, AllowedTypes>::value),
-      "[Reanimated] SimpleValueInterpolator: All interpolated types must inherit from CSSValue");
-
- public:
-  using ValueType = CSSValueVariant<AllowedTypes...>;
-
-  explicit SimpleValueInterpolator(
-      const PropertyPath &propertyPath,
-      const ValueType &defaultStyleValue,
-      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
-
- protected:
-  std::shared_ptr<CSSValue> createValue(jsi::Runtime &rt, const jsi::Value &value) const override;
-
-  std::shared_ptr<CSSValue> createValue(const folly::dynamic &value) const override;
-
-  folly::dynamic interpolateValue(
-      double progress,
-      const std::shared_ptr<CSSValue> &fromValue,
-      const std::shared_ptr<CSSValue> &toValue,
-      const ValueInterpolationContext &context) const override;
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/interpolation/values/ValueInterpolator.h>
+
+#include <memory>
+
+namespace reanimated::css {
+
+/**
+ * Concrete implementation of ValueInterpolator for simple CSS values that don't
+ * require resolution before interpolation. This class handles direct
+ * interpolation between values without any additional processing or resolution.
+ */
+template <typename... AllowedTypes>
+class SimpleValueInterpolator : public ValueInterpolator {
+  static_assert(
+      (... && std::is_base_of<CSSValue, AllowedTypes>::value),
+      "[Reanimated] SimpleValueInterpolator: All interpolated types must inherit from CSSValue");
+
+ public:
+  using ValueType = CSSValueVariant<AllowedTypes...>;
+
+  explicit SimpleValueInterpolator(
+      const PropertyPath &propertyPath,
+      const ValueType &defaultStyleValue,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
+
+ protected:
+  std::shared_ptr<CSSValue> createValue(jsi::Runtime &rt, const jsi::Value &value) const override;
+
+  std::shared_ptr<CSSValue> createValue(const folly::dynamic &value) const override;
+
+  folly::dynamic interpolateValue(
+      double progress,
+      const std::shared_ptr<CSSValue> &fromValue,
+      const std::shared_ptr<CSSValue> &toValue,
+      const ValueInterpolationContext &context) const override;
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/values/ValueInterpolator.cpp

@@ -1,146 +1,146 @@
-#include <reanimated/CSS/interpolation/values/ValueInterpolator.h>
-
-#include <memory>
-#include <utility>
-
-namespace reanimated::css {
-
-ValueInterpolator::ValueInterpolator(
-    const PropertyPath &propertyPath,
-    const std::shared_ptr<CSSValue> &defaultValue,
-    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
-    : PropertyInterpolator(propertyPath, viewStylesRepository),
-      defaultStyleValue_(defaultValue),
-      defaultStyleValueDynamic_(defaultValue->toDynamic()) {}
-
-folly::dynamic ValueInterpolator::getStyleValue(const std::shared_ptr<const ShadowNode> &shadowNode) const {
-  return viewStylesRepository_->getStyleProp(shadowNode->getTag(), propertyPath_);
-}
-
-folly::dynamic ValueInterpolator::getResetStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const {
-  auto styleValue = getStyleValue(shadowNode);
-
-  if (styleValue.isNull()) {
-    return defaultStyleValueDynamic_;
-  }
-
-  return styleValue;
-}
-
-folly::dynamic ValueInterpolator::getFirstKeyframeValue() const {
-  return convertOptionalToDynamic(keyframes_.front().value);
-}
-
-folly::dynamic ValueInterpolator::getLastKeyframeValue() const {
-  return convertOptionalToDynamic(keyframes_.back().value);
-}
-
-bool ValueInterpolator::equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const {
-  if (reversingAdjustedStartValue_.isNull()) {
-    return propertyValue.isNull();
-  }
-  return reversingAdjustedStartValue_ == propertyValue;
-}
-
-void ValueInterpolator::updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) {
-  const auto parsedKeyframes = parseJSIKeyframes(rt, keyframes);
-
-  keyframes_.clear();
-  keyframes_.reserve(parsedKeyframes.size());
-
-  for (const auto &[offset, value] : parsedKeyframes) {
-    if (value.isUndefined()) {
-      keyframes_.emplace_back(offset, std::nullopt);
-    } else {
-      keyframes_.emplace_back(offset, std::make_optional(createValue(rt, value)));
-    }
-  }
-}
-
-void ValueInterpolator::updateKeyframesFromStyleChange(
-    const folly::dynamic &oldStyleValue,
-    const folly::dynamic &newStyleValue,
-    const folly::dynamic &lastUpdateValue) {
-  ValueKeyframe firstKeyframe, lastKeyframe;
-
-  if (!lastUpdateValue.isNull()) {
-    firstKeyframe = ValueKeyframe{0, createValue(lastUpdateValue)};
-  } else if (!oldStyleValue.isNull()) {
-    firstKeyframe = ValueKeyframe{0, createValue(oldStyleValue)};
-  } else {
-    firstKeyframe = ValueKeyframe{0, defaultStyleValue_};
-  }
-
-  if (newStyleValue.isNull()) {
-    lastKeyframe = ValueKeyframe{1, defaultStyleValue_};
-  } else {
-    lastKeyframe = ValueKeyframe{1, createValue(newStyleValue)};
-  }
-
-  keyframes_ = {std::move(firstKeyframe), std::move(lastKeyframe)};
-  reversingAdjustedStartValue_ = oldStyleValue;
-}
-
-folly::dynamic ValueInterpolator::interpolate(
-    const std::shared_ptr<const ShadowNode> &shadowNode,
-    const std::shared_ptr<KeyframeProgressProvider> &progressProvider,
-    const double fallbackInterpolateThreshold) const {
-  const auto toIndex = getToKeyframeIndex(progressProvider);
-  const auto fromIndex = toIndex - 1;
-
-  const auto &fromKeyframe = keyframes_[fromIndex];
-  const auto &toKeyframe = keyframes_[toIndex];
-
-  // clang-format off
-  const auto &fromValue = fromKeyframe.value
-      ? fromKeyframe.value.value()
-      : getFallbackValue(shadowNode);
-  const auto &toValue = toKeyframe.value
-      ? toKeyframe.value.value()
-      : getFallbackValue(shadowNode);
-  // clang-format on
-
-  const auto keyframeProgress = progressProvider->getKeyframeProgress(fromKeyframe.offset, toKeyframe.offset);
-
-  if (keyframeProgress == 1.0) {
-    return toValue->toDynamic();
-  }
-  if (keyframeProgress == 0.0) {
-    return fromValue->toDynamic();
-  }
-
-  return interpolateValue(
-      keyframeProgress,
-      fromValue,
-      toValue,
-      {.node = shadowNode, .fallbackInterpolateThreshold = fallbackInterpolateThreshold});
-}
-
-folly::dynamic ValueInterpolator::convertOptionalToDynamic(
-    const std::optional<std::shared_ptr<CSSValue>> &value) const {
-  return value ? value.value()->toDynamic() : folly::dynamic();
-}
-
-std::shared_ptr<CSSValue> ValueInterpolator::getFallbackValue(
-    const std::shared_ptr<const ShadowNode> &shadowNode) const {
-  const auto styleValue = getStyleValue(shadowNode);
-  return styleValue.isNull() ? defaultStyleValue_ : createValue(styleValue);
-}
-
-size_t ValueInterpolator::getToKeyframeIndex(const std::shared_ptr<KeyframeProgressProvider> &progressProvider) const {
-  const auto progress = progressProvider->getGlobalProgress();
-
-  const auto it = std::upper_bound(
-      keyframes_.begin(), keyframes_.end(), progress, [](double progress, const ValueKeyframe &keyframe) {
-        return progress < keyframe.offset;
-      });
-
-  // If we're at the end, return the last valid keyframe index
-  if (it == keyframes_.end()) {
-    return keyframes_.size() - 1;
-  }
-
-  return std::distance(keyframes_.begin(), it);
-}
-
-} // namespace reanimated::css
+#include <reanimated/CSS/interpolation/values/ValueInterpolator.h>
+
+#include <memory>
+#include <utility>
+
+namespace reanimated::css {
+
+ValueInterpolator::ValueInterpolator(
+    const PropertyPath &propertyPath,
+    const std::shared_ptr<CSSValue> &defaultValue,
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
+    : PropertyInterpolator(propertyPath, viewStylesRepository),
+      defaultStyleValue_(defaultValue),
+      defaultStyleValueDynamic_(defaultValue->toDynamic()) {}
+
+folly::dynamic ValueInterpolator::getStyleValue(const std::shared_ptr<const ShadowNode> &shadowNode) const {
+  return viewStylesRepository_->getStyleProp(shadowNode->getTag(), propertyPath_);
+}
+
+folly::dynamic ValueInterpolator::getResetStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const {
+  auto styleValue = getStyleValue(shadowNode);
+
+  if (styleValue.isNull()) {
+    return defaultStyleValueDynamic_;
+  }
+
+  return styleValue;
+}
+
+folly::dynamic ValueInterpolator::getFirstKeyframeValue() const {
+  return convertOptionalToDynamic(keyframes_.front().value);
+}
+
+folly::dynamic ValueInterpolator::getLastKeyframeValue() const {
+  return convertOptionalToDynamic(keyframes_.back().value);
+}
+
+bool ValueInterpolator::equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const {
+  if (reversingAdjustedStartValue_.isNull()) {
+    return propertyValue.isNull();
+  }
+  return reversingAdjustedStartValue_ == propertyValue;
+}
+
+void ValueInterpolator::updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) {
+  const auto parsedKeyframes = parseJSIKeyframes(rt, keyframes);
+
+  keyframes_.clear();
+  keyframes_.reserve(parsedKeyframes.size());
+
+  for (const auto &[offset, value] : parsedKeyframes) {
+    if (value.isUndefined()) {
+      keyframes_.emplace_back(offset, std::nullopt);
+    } else {
+      keyframes_.emplace_back(offset, std::make_optional(createValue(rt, value)));
+    }
+  }
+}
+
+void ValueInterpolator::updateKeyframesFromStyleChange(
+    const folly::dynamic &oldStyleValue,
+    const folly::dynamic &newStyleValue,
+    const folly::dynamic &lastUpdateValue) {
+  ValueKeyframe firstKeyframe, lastKeyframe;
+
+  if (!lastUpdateValue.isNull()) {
+    firstKeyframe = ValueKeyframe{0, createValue(lastUpdateValue)};
+  } else if (!oldStyleValue.isNull()) {
+    firstKeyframe = ValueKeyframe{0, createValue(oldStyleValue)};
+  } else {
+    firstKeyframe = ValueKeyframe{0, defaultStyleValue_};
+  }
+
+  if (newStyleValue.isNull()) {
+    lastKeyframe = ValueKeyframe{1, defaultStyleValue_};
+  } else {
+    lastKeyframe = ValueKeyframe{1, createValue(newStyleValue)};
+  }
+
+  keyframes_ = {std::move(firstKeyframe), std::move(lastKeyframe)};
+  reversingAdjustedStartValue_ = oldStyleValue;
+}
+
+folly::dynamic ValueInterpolator::interpolate(
+    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const std::shared_ptr<KeyframeProgressProvider> &progressProvider,
+    const double fallbackInterpolateThreshold) const {
+  const auto toIndex = getToKeyframeIndex(progressProvider);
+  const auto fromIndex = toIndex - 1;
+
+  const auto &fromKeyframe = keyframes_[fromIndex];
+  const auto &toKeyframe = keyframes_[toIndex];
+
+  // clang-format off
+  const auto &fromValue = fromKeyframe.value
+      ? fromKeyframe.value.value()
+      : getFallbackValue(shadowNode);
+  const auto &toValue = toKeyframe.value
+      ? toKeyframe.value.value()
+      : getFallbackValue(shadowNode);
+  // clang-format on
+
+  const auto keyframeProgress = progressProvider->getKeyframeProgress(fromKeyframe.offset, toKeyframe.offset);
+
+  if (keyframeProgress == 1.0) {
+    return toValue->toDynamic();
+  }
+  if (keyframeProgress == 0.0) {
+    return fromValue->toDynamic();
+  }
+
+  return interpolateValue(
+      keyframeProgress,
+      fromValue,
+      toValue,
+      {.node = shadowNode, .fallbackInterpolateThreshold = fallbackInterpolateThreshold});
+}
+
+folly::dynamic ValueInterpolator::convertOptionalToDynamic(
+    const std::optional<std::shared_ptr<CSSValue>> &value) const {
+  return value ? value.value()->toDynamic() : folly::dynamic();
+}
+
+std::shared_ptr<CSSValue> ValueInterpolator::getFallbackValue(
+    const std::shared_ptr<const ShadowNode> &shadowNode) const {
+  const auto styleValue = getStyleValue(shadowNode);
+  return styleValue.isNull() ? defaultStyleValue_ : createValue(styleValue);
+}
+
+size_t ValueInterpolator::getToKeyframeIndex(const std::shared_ptr<KeyframeProgressProvider> &progressProvider) const {
+  const auto progress = progressProvider->getGlobalProgress();
+
+  const auto it = std::upper_bound(
+      keyframes_.begin(), keyframes_.end(), progress, [](double progress, const ValueKeyframe &keyframe) {
+        return progress < keyframe.offset;
+      });
+
+  // If we're at the end, return the last valid keyframe index
+  if (it == keyframes_.end()) {
+    return keyframes_.size() - 1;
+  }
+
+  return std::distance(keyframes_.begin(), it);
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/values/ValueInterpolator.h

@@ -1,71 +1,71 @@
-#pragma once
-
-#include <reanimated/CSS/common/values/CSSValueVariant.h>
-#include <reanimated/CSS/interpolation/PropertyInterpolator.h>
-
-#include <memory>
-#include <optional>
-#include <vector>
-
-namespace reanimated::css {
-
-struct ValueKeyframe {
-  double offset;
-  std::optional<std::shared_ptr<CSSValue>> value;
-  ValueKeyframe() : offset(0.0), value(std::nullopt) {}      
-  ValueKeyframe(double offset, std::optional<std::shared_ptr<CSSValue>> value = std::nullopt)
-    : offset(offset), value(std::move(value)) {}            
-};
-
-/**
- * Base class for CSS value interpolators that provides common functionality
- * for interpolating CSS values during animations. This class should be extended
- * by concrete implementations for specific CSS value types to provide
- * type-specific interpolation logic.
- */
-class ValueInterpolator : public PropertyInterpolator {
- public:
-  explicit ValueInterpolator(
-      const PropertyPath &propertyPath,
-      const std::shared_ptr<CSSValue> &defaultValue,
-      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
-  virtual ~ValueInterpolator() = default;
-
-  folly::dynamic getStyleValue(const std::shared_ptr<const ShadowNode> &shadowNode) const override;
-  folly::dynamic getResetStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const override;
-  folly::dynamic getFirstKeyframeValue() const override;
-  folly::dynamic getLastKeyframeValue() const override;
-  bool equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const override;
-
-  void updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) override;
-  void updateKeyframesFromStyleChange(
-      const folly::dynamic &oldStyleValue,
-      const folly::dynamic &newStyleValue,
-      const folly::dynamic &lastUpdateValue) override;
-
-  folly::dynamic interpolate(
-      const std::shared_ptr<const ShadowNode> &shadowNode,
-      const std::shared_ptr<KeyframeProgressProvider> &progressProvider,
-      double fallbackInterpolateThreshold) const override;
-
- protected:
-  std::vector<ValueKeyframe> keyframes_;
-  std::shared_ptr<CSSValue> defaultStyleValue_;
-  folly::dynamic defaultStyleValueDynamic_;
-  folly::dynamic reversingAdjustedStartValue_;
-
-  virtual std::shared_ptr<CSSValue> createValue(jsi::Runtime &rt, const jsi::Value &value) const = 0;
-  virtual std::shared_ptr<CSSValue> createValue(const folly::dynamic &value) const = 0;
-  virtual folly::dynamic interpolateValue(
-      double progress,
-      const std::shared_ptr<CSSValue> &fromValue,
-      const std::shared_ptr<CSSValue> &toValue,
-      const ValueInterpolationContext &context) const = 0;
-
- private:
-  folly::dynamic convertOptionalToDynamic(const std::optional<std::shared_ptr<CSSValue>> &value) const;
-  std::shared_ptr<CSSValue> getFallbackValue(const std::shared_ptr<const ShadowNode> &shadowNode) const;
-  size_t getToKeyframeIndex(const std::shared_ptr<KeyframeProgressProvider> &progressProvider) const;
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSValueVariant.h>
+#include <reanimated/CSS/interpolation/PropertyInterpolator.h>
+
+#include <memory>
+#include <optional>
+#include <vector>
+
+namespace reanimated::css {
+
+struct ValueKeyframe {
+  double offset;
+  std::optional<std::shared_ptr<CSSValue>> value;
+  ValueKeyframe() : offset(0.0), value(std::nullopt) {}      
+  ValueKeyframe(double offset, std::optional<std::shared_ptr<CSSValue>> value = std::nullopt)
+    : offset(offset), value(std::move(value)) {}            
+};
+
+/**
+ * Base class for CSS value interpolators that provides common functionality
+ * for interpolating CSS values during animations. This class should be extended
+ * by concrete implementations for specific CSS value types to provide
+ * type-specific interpolation logic.
+ */
+class ValueInterpolator : public PropertyInterpolator {
+ public:
+  explicit ValueInterpolator(
+      const PropertyPath &propertyPath,
+      const std::shared_ptr<CSSValue> &defaultValue,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
+  virtual ~ValueInterpolator() = default;
+
+  folly::dynamic getStyleValue(const std::shared_ptr<const ShadowNode> &shadowNode) const override;
+  folly::dynamic getResetStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const override;
+  folly::dynamic getFirstKeyframeValue() const override;
+  folly::dynamic getLastKeyframeValue() const override;
+  bool equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const override;
+
+  void updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) override;
+  void updateKeyframesFromStyleChange(
+      const folly::dynamic &oldStyleValue,
+      const folly::dynamic &newStyleValue,
+      const folly::dynamic &lastUpdateValue) override;
+
+  folly::dynamic interpolate(
+      const std::shared_ptr<const ShadowNode> &shadowNode,
+      const std::shared_ptr<KeyframeProgressProvider> &progressProvider,
+      double fallbackInterpolateThreshold) const override;
+
+ protected:
+  std::vector<ValueKeyframe> keyframes_;
+  std::shared_ptr<CSSValue> defaultStyleValue_;
+  folly::dynamic defaultStyleValueDynamic_;
+  folly::dynamic reversingAdjustedStartValue_;
+
+  virtual std::shared_ptr<CSSValue> createValue(jsi::Runtime &rt, const jsi::Value &value) const = 0;
+  virtual std::shared_ptr<CSSValue> createValue(const folly::dynamic &value) const = 0;
+  virtual folly::dynamic interpolateValue(
+      double progress,
+      const std::shared_ptr<CSSValue> &fromValue,
+      const std::shared_ptr<CSSValue> &toValue,
+      const ValueInterpolationContext &context) const = 0;
+
+ private:
+  folly::dynamic convertOptionalToDynamic(const std::optional<std::shared_ptr<CSSValue>> &value) const;
+  std::shared_ptr<CSSValue> getFallbackValue(const std::shared_ptr<const ShadowNode> &shadowNode) const;
+  size_t getToKeyframeIndex(const std::shared_ptr<KeyframeProgressProvider> &progressProvider) const;
+};
+
+} // namespace reanimated::css