react-native-reanimated 4.0.2 → 4.1.0-jsx-fix

package/Common/cpp/reanimated/CSS/common/transforms/TransformOp.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <array>
+#include <string>
+#include <unordered_map>
+
+namespace reanimated::css {
+
+enum class TransformOp {
+  Perspective,
+  Rotate,
+  RotateX,
+  RotateY,
+  RotateZ,
+  Scale,
+  ScaleX,
+  ScaleY,
+  TranslateX,
+  TranslateY,
+  SkewX,
+  SkewY,
+  Matrix,
+};
+
+TransformOp getTransformOperationType(const std::string &property);
+
+std::string getOperationNameFromType(const TransformOp type);
+
+} // namespace reanimated::css

package/Common/cpp/reanimated/CSS/common/{vectors.cpp → transforms/vectors.cpp}

@@ -1,7 +1,70 @@
-#include <reanimated/CSS/common/vectors.h>
+#include <reanimated/CSS/common/transforms/vectors.h>
 
 namespace reanimated::css {
 
+// Vector2D
+
+double &Vector2D::operator[](const size_t idx) {
+  return vec[idx];
+}
+
+const double &Vector2D::operator[](const size_t idx) const {
+  return vec[idx];
+}
+
+Vector2D &Vector2D::operator*=(const double scalar) {
+  vec[0] *= scalar;
+  vec[1] *= scalar;
+  return *this;
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const Vector2D &vector) {
+  os << "Vector2D(" << vector.vec[0] << ", " << vector.vec[1] << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+double Vector2D::length() const {
+  return std::hypot(vec[0], vec[1]);
+}
+
+void Vector2D::scaleToLength(double targetLength) {
+  double currentLength = length();
+  if (currentLength != 0) {
+    double factor = targetLength / currentLength;
+    vec[0] *= factor;
+    vec[1] *= factor;
+  }
+}
+
+void Vector2D::normalize() {
+  scaleToLength(1);
+}
+
+double Vector2D::dot(const Vector2D &other) const {
+  return vec[0] * other.vec[0] + vec[1] * other.vec[1];
+}
+
+double Vector2D::cross(const Vector2D &other) const {
+  return vec[0] * other.vec[1] - vec[1] * other.vec[0];
+}
+
+Vector2D Vector2D::addScaled(const Vector2D &other, const double scale) const {
+  return Vector2D{vec[0] + scale * other.vec[0], vec[1] + scale * other.vec[1]};
+}
+
+Vector2D Vector2D::interpolate(const double progress, const Vector2D &other)
+    const {
+  return Vector2D{
+      vec[0] + progress * (other.vec[0] - vec[0]),
+      vec[1] + progress * (other.vec[1] - vec[1])};
+}
+
+// Vector3D
+
 double &Vector3D::operator[](const size_t idx) {
   return vec[idx];
 }
@@ -71,6 +134,8 @@ Vector3D Vector3D::interpolate(const double progress, const Vector3D &other)
       vec[2] + progress * (other.vec[2] - vec[2])};
 }
 
+// Vector4D
+
 double &Vector4D::operator[](const size_t idx) {
   return vec[idx];
 }

package/Common/cpp/reanimated/CSS/common/{vectors.h → transforms/vectors.h}

@@ -11,6 +11,30 @@
 
 namespace reanimated::css {
 
+struct Vector2D {
+  std::array<double, 2> vec;
+
+  Vector2D() : vec({0, 0}) {}
+  explicit Vector2D(double x, double y) : vec({x, y}) {}
+  explicit Vector2D(std::array<double, 2> vec) : vec(vec) {}
+
+  double &operator[](size_t idx);
+  const double &operator[](size_t idx) const;
+  Vector2D &operator*=(double scalar);
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const Vector2D &vector);
+#endif // NDEBUG
+
+  double length() const;
+  void scaleToLength(double targetLength);
+  void normalize();
+  double dot(const Vector2D &other) const;
+  double cross(const Vector2D &other) const;
+  Vector2D addScaled(const Vector2D &other, double scale) const;
+  Vector2D interpolate(double progress, const Vector2D &other) const;
+};
+
 struct Vector3D {
   std::array<double, 3> vec;
 

package/Common/cpp/reanimated/CSS/common/values/CSSAngle.cpp

@@ -42,6 +42,8 @@ CSSAngle::CSSAngle(const std::string &rotationString) {
   this->value = numericValue * it->second;
 }
 
+CSSAngle::CSSAngle(const char *cstr) : CSSAngle(std::string_view{cstr}) {}
+
 CSSAngle::CSSAngle(jsi::Runtime &rt, const jsi::Value &jsiValue) {
   if (!jsiValue.isString()) {
     throw std::invalid_argument(
@@ -53,9 +55,22 @@ CSSAngle::CSSAngle(jsi::Runtime &rt, const jsi::Value &jsiValue) {
   *this = CSSAngle(strValue);
 }
 
+CSSAngle::CSSAngle(const folly::dynamic &value) {
+  if (!value.isString()) {
+    throw std::invalid_argument(
+        "[Reanimated] CSSAngle: Invalid value type: " + folly::toJson(value));
+  }
+
+  *this = CSSAngle(value.asString());
+}
+
 bool CSSAngle::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
   // TODO - improve canConstruct check and add check for string correctness
-  return jsiValue.isString();
+  return jsiValue.isString() || jsiValue.isNumber();
+}
+
+bool CSSAngle::canConstruct(const folly::dynamic &value) {
+  return value.isString() || value.isNumber();
 }
 
 folly::dynamic CSSAngle::toDynamic() const {

package/Common/cpp/reanimated/CSS/common/values/CSSAngle.h

@@ -4,10 +4,12 @@
 
 #include <worklets/Tools/JSISerializer.h>
 
+#include <folly/json.h>
 #include <iomanip>
 #include <regex>
 #include <sstream>
 #include <string>
+#include <string_view>
 #include <unordered_map>
 
 namespace reanimated::css {
@@ -20,9 +22,12 @@ struct CSSAngle : public CSSSimpleValue<CSSAngle> {
   CSSAngle();
   explicit CSSAngle(double value);
   explicit CSSAngle(const std::string &rotationString);
+  explicit CSSAngle(const char *cstr);
   explicit CSSAngle(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  explicit CSSAngle(const folly::dynamic &value);
 
   static bool canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  static bool canConstruct(const folly::dynamic &value);
 
   folly::dynamic toDynamic() const override;
   std::string toString() const override;

package/Common/cpp/reanimated/CSS/common/values/CSSColor.cpp

@@ -1,4 +1,3 @@
-#include <folly/json.h>
 #include <reanimated/CSS/common/values/CSSColor.h>
 
 namespace reanimated::css {
@@ -9,6 +8,39 @@ CSSColor::CSSColor()
 CSSColor::CSSColor(ColorType colorType)
     : channels{0, 0, 0, 0}, colorType(colorType) {}
 
+CSSColor::CSSColor(int64_t numberValue)
+    : channels{0, 0, 0, 0}, colorType(ColorType::Rgba) {
+  uint32_t color;
+  // On Android, colors are represented as signed 32-bit integers. In JS, we use
+  // a bitwise operation (normalizedColor = normalizedColor | 0x0) to ensure the
+  // value is treated as a signed int, causing numbers above 2^31 to become
+  // negative. To correctly interpret these in C++, we cast negative values to
+  // int32_t to preserve their bit pattern, then assign to uint32_t. This wraps
+  // the bits (modulo 2^32), effectively reversing the JS-side bit shift.
+  if (numberValue < 0) {
+    color = static_cast<int32_t>(numberValue);
+  } else {
+    color = static_cast<uint32_t>(numberValue);
+  }
+  channels[0] = (color >> 16) & 0xFF; // Red
+  channels[1] = (color >> 8) & 0xFF; // Green
+  channels[2] = color & 0xFF; // Blue
+  channels[3] = (color >> 24) & 0xFF; // Alpha
+  colorType = ColorType::Rgba;
+}
+
+CSSColor::CSSColor(const std::string &colorString)
+    : channels{0, 0, 0, 0}, colorType(ColorType::Transparent) {
+  if (colorString == "transparent") {
+    colorType = ColorType::Transparent;
+  } else if (colorString == "currentColor") {
+    colorType = ColorType::CurrentColor;
+  } else {
+    throw std::invalid_argument(
+        "[Reanimated] CSSColor: Invalid string value: " + colorString);
+  }
+}
+
 CSSColor::CSSColor(const uint8_t r, const uint8_t g, const uint8_t b)
     : channels{r, g, b, 255}, colorType(ColorType::Rgba) {}
 
@@ -26,26 +58,14 @@ CSSColor::CSSColor(const ColorChannels &colorChannels)
 CSSColor::CSSColor(jsi::Runtime &rt, const jsi::Value &jsiValue)
     : channels{0, 0, 0, 0}, colorType(ColorType::Transparent) {
   if (jsiValue.isNumber()) {
-    double numberValue = jsiValue.asNumber();
-    uint32_t color;
-    if (numberValue < 0) {
-      color = static_cast<int32_t>(numberValue);
-    } else {
-      color = static_cast<uint32_t>(numberValue);
-    }
-    channels[0] = (color >> 16) & 0xFF; // Red
-    channels[1] = (color >> 8) & 0xFF; // Green
-    channels[2] = color & 0xFF; // Blue
-    channels[3] = (color >> 24) & 0xFF; // Alpha
-    colorType = ColorType::Rgba;
-  } else if (
-      jsiValue.isUndefined() ||
-      (jsiValue.isString() &&
-       jsiValue.getString(rt).utf8(rt) == "transparent")) {
-    colorType = ColorType::Transparent;
+    *this = CSSColor(jsiValue.getNumber());
+  } else if (jsiValue.isString()) {
+    *this = CSSColor(jsiValue.getString(rt).utf8(rt));
+  } else if (jsiValue.isUndefined()) {
+    *this = Transparent;
   } else {
     throw std::invalid_argument(
-        "[Reanimated] CSSColor: Invalid value type: " +
+        "[Reanimated] CSSColor: Invalid value: " +
         stringifyJSIValue(rt, jsiValue));
   }
 }
@@ -53,36 +73,26 @@ CSSColor::CSSColor(jsi::Runtime &rt, const jsi::Value &jsiValue)
 CSSColor::CSSColor(const folly::dynamic &value)
     : channels{0, 0, 0, 0}, colorType(ColorType::Transparent) {
   if (value.isNumber()) {
-    double numberValue = value.asDouble();
-    uint32_t color;
-    if (numberValue < 0) {
-      color = static_cast<int32_t>(numberValue);
-    } else {
-      color = static_cast<uint32_t>(numberValue);
-    }
-    channels[0] = (color >> 16) & 0xFF; // Red
-    channels[1] = (color >> 8) & 0xFF; // Green
-    channels[2] = color & 0xFF; // Blue
-    channels[3] = (color >> 24) & 0xFF; // Alpha
-    colorType = ColorType::Rgba;
-  } else if (
-      value.empty() ||
-      (value.isString() && value.getString() == "transparent")) {
-    colorType = ColorType::Transparent;
+    *this = CSSColor(value.asInt());
+  } else if (value.isString()) {
+    *this = CSSColor(value.getString());
+  } else if (value.empty()) {
+    *this = Transparent;
   } else {
     throw std::invalid_argument(
-        "[Reanimated] CSSColor: Invalid value type: " + folly::toJson(value));
+        "[Reanimated] CSSColor: Invalid value: " + folly::toJson(value));
   }
 }
 
 bool CSSColor::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-  // TODO - improve canConstruct check and add check for string correctness
-  return jsiValue.isNumber() || jsiValue.isString();
+  return jsiValue.isNumber() || jsiValue.isUndefined() ||
+      (jsiValue.isString() &&
+       isValidColorString(jsiValue.getString(rt).utf8(rt)));
 }
 
 bool CSSColor::canConstruct(const folly::dynamic &value) {
-  // TODO - improve canConstruct check and add check for string correctness
-  return value.isNumber() || value.isString();
+  return value.isNumber() || value.empty() ||
+      (value.isString() && isValidColorString(value.getString()));
 }
 
 folly::dynamic CSSColor::toDynamic() const {
@@ -98,16 +108,20 @@ std::string CSSColor::toString() const {
     return "rgba(" + std::to_string(channels[0]) + "," +
         std::to_string(channels[1]) + "," + std::to_string(channels[2]) + "," +
         std::to_string(channels[3]) + ")";
-  } else {
-    return "transparent";
   }
+  if (colorType == ColorType::CurrentColor) {
+    return "currentColor";
+  }
+  return "transparent";
 }
 
 CSSColor CSSColor::interpolate(const double progress, const CSSColor &to)
     const {
-  if (to.colorType == ColorType::Transparent &&
-      colorType == ColorType::Transparent) {
-    return *this;
+  if ((to.colorType == ColorType::Transparent &&
+       colorType == ColorType::Transparent) ||
+      colorType == ColorType::CurrentColor ||
+      to.colorType == ColorType::CurrentColor) {
+    return progress < 0.5 ? *this : to;
   }
 
   ColorChannels fromChannels = channels;
@@ -152,4 +166,8 @@ std::ostream &operator<<(std::ostream &os, const CSSColor &colorValue) {
 
 #endif // NDEBUG
 
+bool CSSColor::isValidColorString(const std::string &colorString) {
+  return colorString == "transparent" || colorString == "currentColor";
+}
+
 } // namespace reanimated::css

package/Common/cpp/reanimated/CSS/common/values/CSSColor.h

@@ -5,6 +5,7 @@
 
 #include <worklets/Tools/JSISerializer.h>
 
+#include <folly/json.h>
 #include <string>
 
 namespace reanimated::css {
@@ -14,6 +15,7 @@ using namespace worklets;
 enum class ColorType {
   Rgba,
   Transparent,
+  CurrentColor, // for SVG
 };
 
 struct CSSColor : public CSSSimpleValue<CSSColor> {
@@ -24,9 +26,13 @@ struct CSSColor : public CSSSimpleValue<CSSColor> {
 
   CSSColor();
   explicit CSSColor(ColorType colorType);
+  explicit CSSColor(int64_t numberValue);
+  explicit CSSColor(const std::string &colorString);
+
   explicit CSSColor(uint8_t r, uint8_t g, uint8_t b);
   explicit CSSColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
   explicit CSSColor(const ColorChannels &colorChannels);
+
   explicit CSSColor(jsi::Runtime &rt, const jsi::Value &jsiValue);
   explicit CSSColor(const folly::dynamic &value);
 
@@ -44,6 +50,9 @@ struct CSSColor : public CSSSimpleValue<CSSColor> {
 #ifndef NDEBUG
   friend std::ostream &operator<<(std::ostream &os, const CSSColor &colorValue);
 #endif // NDEBUG
+
+ private:
+  static bool isValidColorString(const std::string &colorString);
 };
 
 inline const CSSColor CSSColor::Transparent(ColorType::Transparent);

package/Common/cpp/reanimated/CSS/common/values/{CSSDimension.cpp → CSSLength.cpp}

@@ -1,19 +1,18 @@
-#include <reanimated/CSS/common/values/CSSDimension.h>
+#include <reanimated/CSS/common/values/CSSLength.h>
 
 namespace reanimated::css {
 
-CSSDimension::CSSDimension() : value(0), isRelative(false) {}
+CSSLength::CSSLength() : value(0), isRelative(false) {}
 
-CSSDimension::CSSDimension(const double value)
-    : value(value), isRelative(false) {}
+CSSLength::CSSLength(const double value) : value(value), isRelative(false) {}
 
-CSSDimension::CSSDimension(const double value, const bool isRelative)
+CSSLength::CSSLength(const double value, const bool isRelative)
     : value(value), isRelative(isRelative) {}
 
-CSSDimension::CSSDimension(const char *value) {
+CSSLength::CSSLength(const char *value) {
   if (!canConstruct(value)) {
     throw std::invalid_argument(
-        "[Reanimated] CSSDimension: Invalid value: " + std::string(value));
+        "[Reanimated] CSSLength: Invalid value: " + std::string(value));
   }
 
   std::string str = value;
@@ -22,76 +21,72 @@ CSSDimension::CSSDimension(const char *value) {
   this->isRelative = true;
 }
 
-CSSDimension::CSSDimension(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+CSSLength::CSSLength(jsi::Runtime &rt, const jsi::Value &jsiValue) {
   if (jsiValue.isNumber()) {
     this->value = jsiValue.asNumber();
     this->isRelative = false;
   } else if (jsiValue.isString()) {
     std::string strValue = jsiValue.asString(rt).utf8(rt);
-    *this = CSSDimension(strValue); // Delegate to the string constructor
+    *this = CSSLength(strValue); // Delegate to the string constructor
   } else {
-    throw std::runtime_error(
-        "[Reanimated] CSSDimension: Unsupported value type");
+    throw std::runtime_error("[Reanimated] CSSLength: Unsupported value type");
   }
 }
 
-CSSDimension::CSSDimension(const folly::dynamic &value) {
+CSSLength::CSSLength(const folly::dynamic &value) {
   if (value.isNumber()) {
     this->value = value.getDouble();
     this->isRelative = false;
   } else if (value.isString()) {
     std::string strValue = value.getString();
-    *this =
-        CSSDimension(strValue.c_str()); // Delegate to the string constructor
+    *this = CSSLength(strValue.c_str()); // Delegate to the string constructor
   } else {
-    throw std::runtime_error(
-        "[Reanimated] CSSDimension: Unsupported value type");
+    throw std::runtime_error("[Reanimated] CSSLength: Unsupported value type");
   }
 }
 
-bool CSSDimension::canConstruct(const std::string &value) {
+bool CSSLength::canConstruct(const std::string &value) {
   return !value.empty() && value.back() == '%';
 }
 
-bool CSSDimension::canConstruct(const char *value) {
-  auto str = std::string(value);
-  return !str.empty() && str.back() == '%';
+bool CSSLength::canConstruct(const char *value) {
+  return canConstruct(std::string(value));
 }
 
-bool CSSDimension::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+bool CSSLength::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
   return jsiValue.isNumber() ||
       (jsiValue.isString() && canConstruct(jsiValue.getString(rt).utf8(rt)));
 }
 
-bool CSSDimension::canConstruct(const folly::dynamic &value) {
+bool CSSLength::canConstruct(const folly::dynamic &value) {
   return value.isNumber() ||
       (value.isString() && canConstruct(value.getString()));
 }
 
-folly::dynamic CSSDimension::toDynamic() const {
+folly::dynamic CSSLength::toDynamic() const {
   if (isRelative) {
     return std::to_string(value * 100) + "%";
   }
   return value;
 }
 
-std::string CSSDimension::toString() const {
+std::string CSSLength::toString() const {
   if (isRelative) {
     return std::to_string(value * 100) + "%";
   }
   return std::to_string(value);
 }
 
-CSSDimension CSSDimension::interpolate(
+CSSLength CSSLength::interpolate(
     const double progress,
-    const CSSDimension &to,
+    const CSSLength &to,
     const CSSResolvableValueInterpolationContext &context) const {
   // If both value types are the same, we can interpolate without reading the
   // relative value from the shadow node
   // (also, when one of the values is 0, and the other is relative)
   if ((isRelative == to.isRelative) || (isRelative && to.value == 0) ||
       (to.isRelative && value == 0)) {
-    return CSSDimension(
+    return CSSLength(
         value + (to.value - value) * progress, isRelative || to.isRelative);
   }
   // Otherwise, we need to read the relative value from the shadow node and
@@ -102,12 +97,12 @@ CSSDimension CSSDimension::interpolate(
   if (!resolvedFrom.has_value() || !resolvedTo.has_value()) {
     return progress < 0.5 ? *this : to;
   }
-  return CSSDimension(
+  return CSSLength(
       resolvedFrom.value() +
       (resolvedTo.value() - resolvedFrom.value()) * progress);
 }
 
-std::optional<double> CSSDimension::resolve(
+std::optional<double> CSSLength::resolve(
     const CSSResolvableValueInterpolationContext &context) const {
   if (!isRelative) {
     return value;
@@ -129,14 +124,14 @@ std::optional<double> CSSDimension::resolve(
   return value * relativeValue.getNumber();
 }
 
-bool CSSDimension::operator==(const CSSDimension &other) const {
+bool CSSLength::operator==(const CSSLength &other) const {
   return value == other.value && isRelative == other.isRelative;
 }
 
 #ifndef NDEBUG
 
-std::ostream &operator<<(std::ostream &os, const CSSDimension &dimension) {
-  os << "CSSDimension(" << dimension.toString() << ")";
+std::ostream &operator<<(std::ostream &os, const CSSLength &value) {
+  os << "CSSLength(" << value.toString() << ")";
   return os;
 }
 

package/Common/cpp/reanimated/CSS/common/values/{CSSDimension.h → CSSLength.h}

@@ -6,16 +6,16 @@
 
 namespace reanimated::css {
 
-struct CSSDimension : public CSSResolvableValue<CSSDimension, double> {
+struct CSSLength : public CSSResolvableValue<CSSLength, double> {
   double value;
   bool isRelative;
 
-  CSSDimension();
-  explicit CSSDimension(double value);
-  explicit CSSDimension(double value, bool isRelative);
-  explicit CSSDimension(const char *value);
-  explicit CSSDimension(jsi::Runtime &rt, const jsi::Value &jsiValue);
-  explicit CSSDimension(const folly::dynamic &value);
+  CSSLength();
+  explicit CSSLength(double value);
+  explicit CSSLength(double value, bool isRelative);
+  explicit CSSLength(const char *value);
+  explicit CSSLength(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  explicit CSSLength(const folly::dynamic &value);
 
   static bool canConstruct(const std::string &value);
   static bool canConstruct(const char *value);
@@ -24,19 +24,17 @@ struct CSSDimension : public CSSResolvableValue<CSSDimension, double> {
 
   folly::dynamic toDynamic() const override;
   std::string toString() const override;
-  CSSDimension interpolate(
+  CSSLength interpolate(
       double progress,
-      const CSSDimension &to,
+      const CSSLength &to,
       const CSSResolvableValueInterpolationContext &context) const override;
   std::optional<double> resolve(
       const CSSResolvableValueInterpolationContext &context) const override;
 
-  bool operator==(const CSSDimension &other) const;
+  bool operator==(const CSSLength &other) const;
 
 #ifndef NDEBUG
-  friend std::ostream &operator<<(
-      std::ostream &os,
-      const CSSDimension &dimension);
+  friend std::ostream &operator<<(std::ostream &os, const CSSLength &dimension);
 #endif // NDEBUG
 };
 

package/Common/cpp/reanimated/CSS/common/values/CSSValueVariant.h

@@ -91,7 +91,7 @@ class CSSValueVariant final : public CSSValue {
       // Otherwise, try each type in turn
       if (!tryConstruct(std::forward<TValue>(value))) {
         throw std::runtime_error(
-            "[RNReanimated] No compatible type found for construction");
+            "[Reanimated] No compatible type found for construction");
       }
     }
   }
@@ -220,7 +220,7 @@ class CSSValueVariant final : public CSSValue {
           // For construction from a non-jsi::Value, we perform a runtime
           // canConstruct check only if the type has a canConstruct method.
           // (this is needed e.g. when different CSS value types can be
-          // constructed from the same value type, like CSSDimension and
+          // constructed from the same value type, like CSSLength and
           // CSSKeyword)
           if (!TCSSValue::canConstruct(std::forward<TValue>(value))) {
             return false;

package/Common/cpp/reanimated/CSS/{config → configs}/CSSAnimationConfig.cpp

@@ -1,4 +1,4 @@
-#include <reanimated/CSS/config/CSSAnimationConfig.h>
+#include <reanimated/CSS/configs/CSSAnimationConfig.h>
 
 namespace reanimated::css {
 

package/Common/cpp/reanimated/CSS/{config → configs}/CSSAnimationConfig.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <reanimated/CSS/config/CSSKeyframesConfig.h>
-#include <reanimated/CSS/config/common.h>
+#include <reanimated/CSS/configs/CSSKeyframesConfig.h>
+#include <reanimated/CSS/configs/common.h>
 #include <reanimated/CSS/easing/EasingFunctions.h>
 
 #include <memory>

package/Common/cpp/reanimated/CSS/{config → configs}/CSSKeyframesConfig.cpp

@@ -1,18 +1,17 @@
-#include <reanimated/CSS/config/CSSKeyframesConfig.h>
+#include <reanimated/CSS/configs/CSSKeyframesConfig.h>
 
 namespace reanimated::css {
 
-std::shared_ptr<AnimationStyleInterpolator> getStyleInterpolator(
+std::shared_ptr<AnimationStyleInterpolator> createStyleInterpolator(
     jsi::Runtime &rt,
     const jsi::Object &config,
+    const std::string &componentName,
     const std::shared_ptr<ViewStylesRepository> &viewStylesRepository) {
-  const auto styleInterpolator =
-      std::make_shared<AnimationStyleInterpolator>(viewStylesRepository);
-
-  const auto keyframes = config.getProperty(rt, "keyframesStyle");
-  styleInterpolator->updateKeyframes(dynamicFromValue(rt, keyframes));
-
-  return styleInterpolator;
+  return std::make_shared<AnimationStyleInterpolator>(
+      rt,
+      config.getProperty(rt, "keyframesStyle"),
+      componentName,
+      viewStylesRepository);
 }
 
 std::shared_ptr<KeyframeEasingFunctions> getKeyframeTimingFunctions(
@@ -40,11 +39,13 @@ std::shared_ptr<KeyframeEasingFunctions> getKeyframeTimingFunctions(
 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 {
-      getStyleInterpolator(rt, configObj, viewStylesRepository),
+      createStyleInterpolator(
+          rt, configObj, componentName, viewStylesRepository),
       getKeyframeTimingFunctions(rt, configObj)};
 }