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

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/transforms/operations/rotate.cpp

@@ -1,41 +1,41 @@
-#include <reanimated/CSS/common/transforms/TransformMatrix3D.h>
-#include <reanimated/CSS/interpolation/transforms/operations/rotate.h>
-
-#include <memory>
-#include <string>
-
-namespace reanimated::css {
-
-template <TransformOp TOperation>
-RotateOperationBase2D<TOperation>::RotateOperationBase2D(const std::string &value)
-    : TransformOperationBase<TOperation, CSSAngle>(CSSAngle(value)) {}
-
-template <TransformOp TOperation>
-RotateOperationBase3D<TOperation>::RotateOperationBase3D(const std::string &value)
-    : TransformOperationBase<TOperation, CSSAngle>(CSSAngle(value)) {}
-
-template <TransformOp TOperation>
-bool RotateOperationBase3D<TOperation>::is3D() const {
-  return true;
-}
-
-template <TransformOp TOperation>
-TransformMatrix::Shared RotateOperationBase3D<TOperation>::toMatrix(bool /* force3D */) const {
-  return std::make_shared<const TransformMatrix3D>(TransformMatrix3D::create<TOperation>(this->value.value));
-}
-
-bool RotateZOperation::canConvertTo(TransformOp type) const {
-  return type == TransformOp::Rotate;
-}
-
-TransformOperations RotateZOperation::convertTo(TransformOp type) const {
-  assertCanConvertTo(type);
-  return {std::make_shared<RotateOperation>(value)};
-}
-
-template struct RotateOperationBase2D<TransformOp::Rotate>;
-template struct RotateOperationBase2D<TransformOp::RotateZ>;
-template struct RotateOperationBase3D<TransformOp::RotateX>;
-template struct RotateOperationBase3D<TransformOp::RotateY>;
-
-} // namespace reanimated::css
+#include <reanimated/CSS/common/transforms/TransformMatrix3D.h>
+#include <reanimated/CSS/interpolation/transforms/operations/rotate.h>
+
+#include <memory>
+#include <string>
+
+namespace reanimated::css {
+
+template <TransformOp TOperation>
+RotateOperationBase2D<TOperation>::RotateOperationBase2D(const std::string &value)
+    : TransformOperationBase<TOperation, CSSAngle>(CSSAngle(value)) {}
+
+template <TransformOp TOperation>
+RotateOperationBase3D<TOperation>::RotateOperationBase3D(const std::string &value)
+    : TransformOperationBase<TOperation, CSSAngle>(CSSAngle(value)) {}
+
+template <TransformOp TOperation>
+bool RotateOperationBase3D<TOperation>::is3D() const {
+  return true;
+}
+
+template <TransformOp TOperation>
+TransformMatrix::Shared RotateOperationBase3D<TOperation>::toMatrix(bool /* force3D */) const {
+  return std::make_shared<const TransformMatrix3D>(TransformMatrix3D::create<TOperation>(this->value.value));
+}
+
+bool RotateZOperation::canConvertTo(TransformOp type) const {
+  return type == TransformOp::Rotate;
+}
+
+TransformOperations RotateZOperation::convertTo(TransformOp type) const {
+  assertCanConvertTo(type);
+  return {std::make_shared<RotateOperation>(value)};
+}
+
+template struct RotateOperationBase2D<TransformOp::Rotate>;
+template struct RotateOperationBase2D<TransformOp::RotateZ>;
+template struct RotateOperationBase3D<TransformOp::RotateX>;
+template struct RotateOperationBase3D<TransformOp::RotateY>;
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/transforms/operations/rotate.h

@@ -1,39 +1,39 @@
-#pragma once
-
-#include <reanimated/CSS/common/transforms/TransformMatrix.h>
-#include <reanimated/CSS/common/values/CSSAngle.h>
-#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
-
-#include <string>
-
-namespace reanimated::css {
-
-template <TransformOp TOperation>
-struct RotateOperationBase2D : public TransformOperationBase<TOperation, CSSAngle> {
-  using TransformOperationBase<TOperation, CSSAngle>::TransformOperationBase;
-
-  explicit RotateOperationBase2D(const std::string &value);
-};
-
-template <TransformOp TOperation>
-struct RotateOperationBase3D : public TransformOperationBase<TOperation, CSSAngle> {
-  using TransformOperationBase<TOperation, CSSAngle>::TransformOperationBase;
-
-  explicit RotateOperationBase3D(const std::string &value);
-
-  bool is3D() const override;
-  TransformMatrix::Shared toMatrix(bool /* force3D */) const override;
-};
-
-using RotateOperation = RotateOperationBase2D<TransformOp::Rotate>;
-using RotateXOperation = RotateOperationBase3D<TransformOp::RotateX>;
-using RotateYOperation = RotateOperationBase3D<TransformOp::RotateY>;
-
-struct RotateZOperation final : public RotateOperationBase2D<TransformOp::RotateZ> {
-  using RotateOperationBase2D<TransformOp::RotateZ>::RotateOperationBase2D;
-
-  bool canConvertTo(TransformOp type) const override;
-  TransformOperations convertTo(TransformOp type) const override;
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/transforms/TransformMatrix.h>
+#include <reanimated/CSS/common/values/CSSAngle.h>
+#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+template <TransformOp TOperation>
+struct RotateOperationBase2D : public TransformOperationBase<TOperation, CSSAngle> {
+  using TransformOperationBase<TOperation, CSSAngle>::TransformOperationBase;
+
+  explicit RotateOperationBase2D(const std::string &value);
+};
+
+template <TransformOp TOperation>
+struct RotateOperationBase3D : public TransformOperationBase<TOperation, CSSAngle> {
+  using TransformOperationBase<TOperation, CSSAngle>::TransformOperationBase;
+
+  explicit RotateOperationBase3D(const std::string &value);
+
+  bool is3D() const override;
+  TransformMatrix::Shared toMatrix(bool /* force3D */) const override;
+};
+
+using RotateOperation = RotateOperationBase2D<TransformOp::Rotate>;
+using RotateXOperation = RotateOperationBase3D<TransformOp::RotateX>;
+using RotateYOperation = RotateOperationBase3D<TransformOp::RotateY>;
+
+struct RotateZOperation final : public RotateOperationBase2D<TransformOp::RotateZ> {
+  using RotateOperationBase2D<TransformOp::RotateZ>::RotateOperationBase2D;
+
+  bool canConvertTo(TransformOp type) const override;
+  TransformOperations convertTo(TransformOp type) const override;
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/transforms/operations/scale.cpp

@@ -1,28 +1,28 @@
-#include <reanimated/CSS/interpolation/transforms/operations/scale.h>
-
-#include <memory>
-
-namespace reanimated::css {
-
-template <TransformOp TOperation>
-ScaleOperationBase<TOperation>::ScaleOperationBase(const double value)
-    : TransformOperationBase<TOperation, CSSDouble>(CSSDouble(value)) {}
-
-bool ScaleOperation::canConvertTo(TransformOp type) const {
-  return type == TransformOp::ScaleX || type == TransformOp::ScaleY;
-}
-
-TransformOperations ScaleOperation::convertTo(TransformOp type) const {
-  assertCanConvertTo(type);
-  if (type == TransformOp::ScaleX) {
-    return {std::make_shared<ScaleXOperation>(value), std::make_shared<ScaleYOperation>(value)};
-  } else {
-    return {std::make_shared<ScaleYOperation>(value), std::make_shared<ScaleXOperation>(value)};
-  }
-}
-
-template struct ScaleOperationBase<TransformOp::ScaleX>;
-template struct ScaleOperationBase<TransformOp::ScaleY>;
-template struct ScaleOperationBase<TransformOp::Scale>;
-
-} // namespace reanimated::css
+#include <reanimated/CSS/interpolation/transforms/operations/scale.h>
+
+#include <memory>
+
+namespace reanimated::css {
+
+template <TransformOp TOperation>
+ScaleOperationBase<TOperation>::ScaleOperationBase(const double value)
+    : TransformOperationBase<TOperation, CSSDouble>(CSSDouble(value)) {}
+
+bool ScaleOperation::canConvertTo(TransformOp type) const {
+  return type == TransformOp::ScaleX || type == TransformOp::ScaleY;
+}
+
+TransformOperations ScaleOperation::convertTo(TransformOp type) const {
+  assertCanConvertTo(type);
+  if (type == TransformOp::ScaleX) {
+    return {std::make_shared<ScaleXOperation>(value), std::make_shared<ScaleYOperation>(value)};
+  } else {
+    return {std::make_shared<ScaleYOperation>(value), std::make_shared<ScaleXOperation>(value)};
+  }
+}
+
+template struct ScaleOperationBase<TransformOp::ScaleX>;
+template struct ScaleOperationBase<TransformOp::ScaleY>;
+template struct ScaleOperationBase<TransformOp::Scale>;
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/transforms/operations/scale.h

@@ -1,25 +1,25 @@
-#pragma once
-
-#include <reanimated/CSS/common/values/CSSNumber.h>
-#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
-
-namespace reanimated::css {
-
-template <TransformOp TOperation>
-struct ScaleOperationBase : public TransformOperationBase<TOperation, CSSDouble> {
-  using TransformOperationBase<TOperation, CSSDouble>::TransformOperationBase;
-
-  explicit ScaleOperationBase(const double value);
-};
-
-using ScaleXOperation = ScaleOperationBase<TransformOp::ScaleX>;
-using ScaleYOperation = ScaleOperationBase<TransformOp::ScaleY>;
-
-struct ScaleOperation final : public ScaleOperationBase<TransformOp::Scale> {
-  using ScaleOperationBase<TransformOp::Scale>::ScaleOperationBase;
-
-  bool canConvertTo(TransformOp type) const override;
-  TransformOperations convertTo(TransformOp type) const override;
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSNumber.h>
+#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
+
+namespace reanimated::css {
+
+template <TransformOp TOperation>
+struct ScaleOperationBase : public TransformOperationBase<TOperation, CSSDouble> {
+  using TransformOperationBase<TOperation, CSSDouble>::TransformOperationBase;
+
+  explicit ScaleOperationBase(const double value);
+};
+
+using ScaleXOperation = ScaleOperationBase<TransformOp::ScaleX>;
+using ScaleYOperation = ScaleOperationBase<TransformOp::ScaleY>;
+
+struct ScaleOperation final : public ScaleOperationBase<TransformOp::Scale> {
+  using ScaleOperationBase<TransformOp::Scale>::ScaleOperationBase;
+
+  bool canConvertTo(TransformOp type) const override;
+  TransformOperations convertTo(TransformOp type) const override;
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/transforms/operations/skew.cpp

@@ -1,14 +1,14 @@
-#include <reanimated/CSS/interpolation/transforms/operations/skew.h>
-
-#include <string>
-
-namespace reanimated::css {
-
-template <TransformOp TOperation>
-SkewOperationBase<TOperation>::SkewOperationBase(const std::string &value)
-    : TransformOperationBase<TOperation, CSSAngle>(CSSAngle(value)) {}
-
-template struct SkewOperationBase<TransformOp::SkewX>;
-template struct SkewOperationBase<TransformOp::SkewY>;
-
-} // namespace reanimated::css
+#include <reanimated/CSS/interpolation/transforms/operations/skew.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+template <TransformOp TOperation>
+SkewOperationBase<TOperation>::SkewOperationBase(const std::string &value)
+    : TransformOperationBase<TOperation, CSSAngle>(CSSAngle(value)) {}
+
+template struct SkewOperationBase<TransformOp::SkewX>;
+template struct SkewOperationBase<TransformOp::SkewY>;
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/transforms/operations/skew.h

@@ -1,20 +1,20 @@
-#pragma once
-
-#include <reanimated/CSS/common/values/CSSAngle.h>
-#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
-
-#include <string>
-
-namespace reanimated::css {
-
-template <TransformOp TOperation>
-struct SkewOperationBase : public TransformOperationBase<TOperation, CSSAngle> {
-  using TransformOperationBase<TOperation, CSSAngle>::TransformOperationBase;
-
-  explicit SkewOperationBase(const std::string &value);
-};
-
-using SkewXOperation = SkewOperationBase<TransformOp::SkewX>;
-using SkewYOperation = SkewOperationBase<TransformOp::SkewY>;
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSAngle.h>
+#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+template <TransformOp TOperation>
+struct SkewOperationBase : public TransformOperationBase<TOperation, CSSAngle> {
+  using TransformOperationBase<TOperation, CSSAngle>::TransformOperationBase;
+
+  explicit SkewOperationBase(const std::string &value);
+};
+
+using SkewXOperation = SkewOperationBase<TransformOp::SkewX>;
+using SkewYOperation = SkewOperationBase<TransformOp::SkewY>;
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/transforms/operations/translate.cpp

@@ -1,39 +1,39 @@
-#include <reanimated/CSS/common/transforms/TransformMatrix2D.h>
-#include <reanimated/CSS/common/transforms/TransformMatrix3D.h>
-#include <reanimated/CSS/interpolation/transforms/operations/translate.h>
-
-#include <memory>
-#include <string>
-
-namespace reanimated::css {
-
-template <TransformOp TOperation>
-TranslateOperationBase<TOperation>::TranslateOperationBase(double value)
-    : TransformOperationBase<TOperation, CSSLength>(CSSLength(value)) {}
-
-template <TransformOp TOperation>
-TranslateOperationBase<TOperation>::TranslateOperationBase(const std::string &value)
-    : TransformOperationBase<TOperation, CSSLength>(CSSLength(value)) {}
-
-template <TransformOp TOperation>
-bool TranslateOperationBase<TOperation>::shouldResolve() const {
-  return this->value.isRelative;
-}
-
-template <TransformOp TOperation>
-TransformMatrix::Shared TranslateOperationBase<TOperation>::toMatrix(bool force3D) const {
-  if (shouldResolve()) {
-    throw std::runtime_error(
-        "[Reanimated] Cannot convert unresolved relative translate value to matrix: " + this->value.toString());
-  }
-
-  if (force3D) {
-    return std::make_shared<TransformMatrix3D>(TransformMatrix3D::create<TOperation>(this->value.value));
-  }
-  return std::make_shared<TransformMatrix2D>(TransformMatrix2D::create<TOperation>(this->value.value));
-}
-
-template struct TranslateOperationBase<TransformOp::TranslateX>;
-template struct TranslateOperationBase<TransformOp::TranslateY>;
-
-} // namespace reanimated::css
+#include <reanimated/CSS/common/transforms/TransformMatrix2D.h>
+#include <reanimated/CSS/common/transforms/TransformMatrix3D.h>
+#include <reanimated/CSS/interpolation/transforms/operations/translate.h>
+
+#include <memory>
+#include <string>
+
+namespace reanimated::css {
+
+template <TransformOp TOperation>
+TranslateOperationBase<TOperation>::TranslateOperationBase(double value)
+    : TransformOperationBase<TOperation, CSSLength>(CSSLength(value)) {}
+
+template <TransformOp TOperation>
+TranslateOperationBase<TOperation>::TranslateOperationBase(const std::string &value)
+    : TransformOperationBase<TOperation, CSSLength>(CSSLength(value)) {}
+
+template <TransformOp TOperation>
+bool TranslateOperationBase<TOperation>::shouldResolve() const {
+  return this->value.isRelative;
+}
+
+template <TransformOp TOperation>
+TransformMatrix::Shared TranslateOperationBase<TOperation>::toMatrix(bool force3D) const {
+  if (shouldResolve()) {
+    throw std::runtime_error(
+        "[Reanimated] Cannot convert unresolved relative translate value to matrix: " + this->value.toString());
+  }
+
+  if (force3D) {
+    return std::make_shared<TransformMatrix3D>(TransformMatrix3D::create<TOperation>(this->value.value));
+  }
+  return std::make_shared<TransformMatrix2D>(TransformMatrix2D::create<TOperation>(this->value.value));
+}
+
+template struct TranslateOperationBase<TransformOp::TranslateX>;
+template struct TranslateOperationBase<TransformOp::TranslateY>;
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/transforms/operations/translate.h

@@ -1,25 +1,25 @@
-#pragma once
-
-#include <reanimated/CSS/common/values/CSSLength.h>
-#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
-
-#include <memory>
-#include <string>
-
-namespace reanimated::css {
-
-template <TransformOp TOperation>
-struct TranslateOperationBase : public TransformOperationBase<TOperation, CSSLength> {
-  using TransformOperationBase<TOperation, CSSLength>::TransformOperationBase;
-
-  explicit TranslateOperationBase(double value);
-  explicit TranslateOperationBase(const std::string &value);
-
-  bool shouldResolve() const override;
-  TransformMatrix::Shared toMatrix(bool force3D) const override;
-};
-
-using TranslateXOperation = TranslateOperationBase<TransformOp::TranslateX>;
-using TranslateYOperation = TranslateOperationBase<TransformOp::TranslateY>;
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSLength.h>
+#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
+
+#include <memory>
+#include <string>
+
+namespace reanimated::css {
+
+template <TransformOp TOperation>
+struct TranslateOperationBase : public TransformOperationBase<TOperation, CSSLength> {
+  using TransformOperationBase<TOperation, CSSLength>::TransformOperationBase;
+
+  explicit TranslateOperationBase(double value);
+  explicit TranslateOperationBase(const std::string &value);
+
+  bool shouldResolve() const override;
+  TransformMatrix::Shared toMatrix(bool force3D) const override;
+};
+
+using TranslateXOperation = TranslateOperationBase<TransformOp::TranslateX>;
+using TranslateYOperation = TranslateOperationBase<TransformOp::TranslateY>;
+
+} // namespace reanimated::css

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

@@ -1,47 +1,47 @@
-#include <reanimated/CSS/interpolation/values/ResolvableValueInterpolator.h>
-
-#include <folly/dynamic.h>
-#include <jsi/jsi.h>
-
-#include <reanimated/CSS/common/values/CSSAngle.h>
-#include <reanimated/CSS/common/values/CSSKeyword.h>
-#include <reanimated/CSS/common/values/CSSLength.h>
-#include <reanimated/CSS/common/values/CSSNumber.h>
-
-#include <memory>
-
-namespace reanimated::css {
-
-template <typename... AllowedTypes>
-ResolvableValueInterpolator<AllowedTypes...>::ResolvableValueInterpolator(
-    const PropertyPath &propertyPath,
-    const ValueType &defaultStyleValue,
-    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository,
-    const ResolvableValueInterpolatorConfig &config)
-    : SimpleValueInterpolator<AllowedTypes...>(propertyPath, defaultStyleValue, viewStylesRepository),
-      config_(config) {}
-
-template <typename... AllowedTypes>
-folly::dynamic ResolvableValueInterpolator<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,
-          {.node = context.node,
-           .fallbackInterpolateThreshold = context.fallbackInterpolateThreshold,
-           .viewStylesRepository = this->viewStylesRepository_,
-           .relativeProperty = config_.relativeProperty,
-           .relativeTo = config_.relativeTo})
-      .toDynamic();
-}
-
-template class ResolvableValueInterpolator<CSSLength>;
-template class ResolvableValueInterpolator<CSSLength, CSSKeyword>;
-
-} // namespace reanimated::css
+#include <reanimated/CSS/interpolation/values/ResolvableValueInterpolator.h>
+
+#include <folly/dynamic.h>
+#include <jsi/jsi.h>
+
+#include <reanimated/CSS/common/values/CSSAngle.h>
+#include <reanimated/CSS/common/values/CSSKeyword.h>
+#include <reanimated/CSS/common/values/CSSLength.h>
+#include <reanimated/CSS/common/values/CSSNumber.h>
+
+#include <memory>
+
+namespace reanimated::css {
+
+template <typename... AllowedTypes>
+ResolvableValueInterpolator<AllowedTypes...>::ResolvableValueInterpolator(
+    const PropertyPath &propertyPath,
+    const ValueType &defaultStyleValue,
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository,
+    const ResolvableValueInterpolatorConfig &config)
+    : SimpleValueInterpolator<AllowedTypes...>(propertyPath, defaultStyleValue, viewStylesRepository),
+      config_(config) {}
+
+template <typename... AllowedTypes>
+folly::dynamic ResolvableValueInterpolator<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,
+          {.node = context.node,
+           .fallbackInterpolateThreshold = context.fallbackInterpolateThreshold,
+           .viewStylesRepository = this->viewStylesRepository_,
+           .relativeProperty = config_.relativeProperty,
+           .relativeTo = config_.relativeTo})
+      .toDynamic();
+}
+
+template class ResolvableValueInterpolator<CSSLength>;
+template class ResolvableValueInterpolator<CSSLength, CSSKeyword>;
+
+} // namespace reanimated::css

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

@@ -1,43 +1,43 @@
-#pragma once
-
-#include <reanimated/CSS/interpolation/configs.h>
-#include <reanimated/CSS/interpolation/values/SimpleValueInterpolator.h>
-
-#include <memory>
-
-namespace reanimated::css {
-
-/**
- * Concrete implementation of ValueInterpolator for CSS values that require
- * resolution before interpolation. This class handles interpolation of relative
- * values (e.g., percentage length values) that need to be resolved to absolute
- * values using the context describing the ShadowNode before the interpolation
- * can occur.
- */
-template <typename... AllowedTypes>
-class ResolvableValueInterpolator final : public SimpleValueInterpolator<AllowedTypes...> {
-  static_assert(
-      (... && std::is_base_of<CSSValue, AllowedTypes>::value),
-      "[Reanimated] ResolvableValueInterpolator: All interpolated types must inherit from CSSValue");
-
- public:
-  using ValueType = typename SimpleValueInterpolator<AllowedTypes...>::ValueType;
-
-  explicit ResolvableValueInterpolator(
-      const PropertyPath &propertyPath,
-      const ValueType &defaultStyleValue,
-      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository,
-      const ResolvableValueInterpolatorConfig &config);
-
- protected:
-  folly::dynamic interpolateValue(
-      double progress,
-      const std::shared_ptr<CSSValue> &fromValue,
-      const std::shared_ptr<CSSValue> &toValue,
-      const ValueInterpolationContext &context) const override;
-
- private:
-  const ResolvableValueInterpolatorConfig &config_;
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/interpolation/configs.h>
+#include <reanimated/CSS/interpolation/values/SimpleValueInterpolator.h>
+
+#include <memory>
+
+namespace reanimated::css {
+
+/**
+ * Concrete implementation of ValueInterpolator for CSS values that require
+ * resolution before interpolation. This class handles interpolation of relative
+ * values (e.g., percentage length values) that need to be resolved to absolute
+ * values using the context describing the ShadowNode before the interpolation
+ * can occur.
+ */
+template <typename... AllowedTypes>
+class ResolvableValueInterpolator final : public SimpleValueInterpolator<AllowedTypes...> {
+  static_assert(
+      (... && std::is_base_of<CSSValue, AllowedTypes>::value),
+      "[Reanimated] ResolvableValueInterpolator: All interpolated types must inherit from CSSValue");
+
+ public:
+  using ValueType = typename SimpleValueInterpolator<AllowedTypes...>::ValueType;
+
+  explicit ResolvableValueInterpolator(
+      const PropertyPath &propertyPath,
+      const ValueType &defaultStyleValue,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository,
+      const ResolvableValueInterpolatorConfig &config);
+
+ protected:
+  folly::dynamic interpolateValue(
+      double progress,
+      const std::shared_ptr<CSSValue> &fromValue,
+      const std::shared_ptr<CSSValue> &toValue,
+      const ValueInterpolationContext &context) const override;
+
+ private:
+  const ResolvableValueInterpolatorConfig &config_;
+};
+
+} // namespace reanimated::css