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

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/svg/values/SVGStops.cpp

@@ -0,0 +1,164 @@
+#include <reanimated/CSS/svg/values/SVGBrush.h>
+#include <reanimated/CSS/svg/values/SVGStops.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <functional>
+#include <optional>
+#include <regex>
+#include <string>
+
+namespace reanimated::css {
+
+SVGStops::SVGStops(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  jsi::Array array = jsiValue.asObject(rt).asArray(rt);
+  size_t length = array.size(rt);
+
+  stops.reserve(length / 2);
+
+  for (size_t i = 0; i < length; i += 2) {
+    double offset = array.getValueAtIndex(rt, i).asNumber();
+    auto colorVal = array.getValueAtIndex(rt, i + 1);
+
+    stops.emplace_back(offset, SVGBrush(rt, colorVal));
+  }
+}
+
+SVGStops::SVGStops(const folly::dynamic &value) {
+  stops.reserve(value.size() / 2);
+
+  for (size_t i = 0; i < value.size(); i += 2) {
+    double offset = value[i].asDouble();
+    stops.emplace_back(offset, SVGBrush(value[i + 1]));
+  }
+}
+
+bool SVGStops::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  if (!jsiValue.isObject()) {
+    return false;
+  }
+
+  auto obj = jsiValue.asObject(rt);
+  if (!obj.isArray(rt)) {
+    return false;
+  }
+
+  auto array = obj.asArray(rt);
+  size_t length = array.size(rt);
+
+  if (length == 0) {
+    return true;
+  }
+
+  // [offset, brush, offset, brush, ...]
+  if (length % 2 != 0) {
+    return false;
+  }
+
+  auto firstOffset = array.getValueAtIndex(rt, 0);
+  auto firstBrush = array.getValueAtIndex(rt, 1);
+
+  return firstOffset.isNumber() && SVGBrush::canConstruct(rt, firstBrush);
+}
+
+bool SVGStops::canConstruct(const folly::dynamic &value) {
+  if (!value.isArray()) {
+    return false;
+  }
+
+  if (value.empty()) {
+    return true;
+  }
+
+  // [offset, brush, offset, brush, ...]
+  if (value.size() % 2 != 0) {
+    return false;
+  }
+
+  const auto &firstOffset = value[0];
+  const auto &firstBrush = value[1];
+
+  return firstOffset.isNumber() && SVGBrush::canConstruct(firstBrush);
+}
+
+folly::dynamic SVGStops::toDynamic() const {
+  folly::dynamic array = folly::dynamic::array;
+
+  for (const auto &stop : stops) {
+    array.push_back(stop.offset);
+    array.push_back(stop.color.toDynamic());
+  }
+
+  return array;
+}
+
+std::string SVGStops::toString() const {
+  if (stops.empty()) {
+    return "none";
+  }
+
+  std::stringstream ss;
+  ss << "stops(";
+  for (size_t i = 0; i < stops.size(); ++i) {
+    ss << stops[i].color.toString() << " " << (stops[i].offset * 100) << "%";
+    if (i < stops.size() - 1) {
+      ss << ", ";
+    }
+  }
+  ss << ")";
+  return ss.str();
+}
+
+SVGStops SVGStops::interpolate(double progress, const SVGStops &to) const {
+  const auto &fromStops = stops;
+  const auto &toStops = to.stops;
+
+  if (fromStops.empty() || toStops.empty()) {
+    return progress < 0.5 ? *this : to;
+  }
+
+  size_t fromSize = fromStops.size();
+  size_t toSize = toStops.size();
+  size_t longerSize = std::max(toSize, fromSize);
+
+  std::vector<GradientStop> interpolatedStops;
+  interpolatedStops.reserve(longerSize);
+
+  for (size_t i = 0; i < longerSize; ++i) {
+    double ratio = (longerSize > 1) ? static_cast<double>(i) / (static_cast<double>(longerSize) - 1.0) : 0.0;
+
+    auto fromIdx = static_cast<size_t>(std::round(ratio * (fromSize - 1)));
+    auto toIdx = static_cast<size_t>(std::round(ratio * (toSize - 1)));
+
+    const auto &sFrom = fromStops[fromIdx];
+    const auto &sTo = toStops[toIdx];
+
+    double mixedOffset = sFrom.offset + (sTo.offset - sFrom.offset) * progress;
+
+    SVGBrush mixedBrush = sFrom.color.interpolate(progress, sTo.color);
+
+    interpolatedStops.emplace_back(mixedOffset, std::move(mixedBrush));
+  }
+
+  return SVGStops(std::move(interpolatedStops));
+}
+
+bool SVGStops::operator==(const SVGStops &other) const {
+  return toString() == other.toString();
+}
+
+#ifndef NDEBUG
+std::ostream &operator<<(std::ostream &os, const SVGStops &value) {
+  os << "SVGStops{ count: " << value.stops.size() << ", data: [";
+  for (size_t i = 0; i < value.stops.size(); ++i) {
+    os << "{ offset: " << value.stops[i].offset << ", brush: " << value.stops[i].color.toString() << " }";
+    if (i < value.stops.size() - 1) {
+      os << ", ";
+    }
+  }
+  os << "] }";
+  return os;
+}
+#endif
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/svg/values/SVGStops.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSValue.h>
+#include <reanimated/CSS/svg/values/SVGBrush.h>
+
+#include <concepts>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace reanimated::css {
+
+struct SVGStops : public CSSSimpleValue<SVGStops> {
+  struct GradientStop {
+    // OHOS patch: clang 15's std::is_constructible doesn't account for
+    // parenthesized aggregate initialization (P0960), so
+    // std::construct_at — used by vector::emplace_back — rejects
+    // GradientStop(double, SVGBrush) ("no matching constructor"). An explicit
+    // constructor bypasses the trait gap; brace initialization keeps working.
+    // Upstream relies on P0960 with clang 17+ (NDK).
+    GradientStop(double offset_, SVGBrush color_) : offset(offset_), color(std::move(color_)) {}
+
+    double offset;
+    SVGBrush color;
+  };
+
+  SVGStops() = default;
+  template <typename T>
+    requires(!std::same_as<std::decay_t<T>, SVGStops>) && std::constructible_from<std::vector<GradientStop>, T>
+  explicit SVGStops(T &&value) : stops{std::forward<T>(value)} {}
+  explicit SVGStops(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  explicit SVGStops(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;
+  SVGStops interpolate(double progress, const SVGStops &to) const override;
+
+  bool operator==(const SVGStops &other) const;
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const SVGStops &dimension);
+#endif // NDEBUG
+
+ private:
+  std::vector<GradientStop> stops;
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/svg/values/SVGStrokeDashArray.cpp

@@ -1,72 +1,15 @@
 #include <reanimated/CSS/svg/values/SVGStrokeDashArray.h>
 
-#include <sstream>
-#include <string>
+#include <numeric>
 #include <vector>
 
 namespace reanimated::css {
 
-SVGStrokeDashArray::SVGStrokeDashArray() : values() {}
-
-SVGStrokeDashArray::SVGStrokeDashArray(const std::vector<SVGLength> &values) : values(values) {}
-
-SVGStrokeDashArray::SVGStrokeDashArray(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-  const auto &array = jsiValue.asObject(rt).asArray(rt);
-  const auto arraySize = array.size(rt);
-  values.reserve(arraySize);
-  for (size_t i = 0; i < arraySize; ++i) {
-    values.emplace_back(rt, array.getValueAtIndex(rt, i));
-  }
-}
-
-SVGStrokeDashArray::SVGStrokeDashArray(const folly::dynamic &value) {
-  for (const auto &value : value) {
-    values.emplace_back(value);
-  }
-}
-
-bool SVGStrokeDashArray::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-  if (!jsiValue.isObject() || !jsiValue.asObject(rt).isArray(rt)) {
-    return false;
-  }
-  const auto &array = jsiValue.asObject(rt).asArray(rt);
-  for (size_t i = 0; i < array.size(rt); ++i) {
-    if (!SVGLength::canConstruct(rt, array.getValueAtIndex(rt, i))) {
-      return false;
-    }
-  }
-  return true;
-}
-
-bool SVGStrokeDashArray::canConstruct(const folly::dynamic &value) {
-  return value.isArray() &&
-      std::all_of(value.begin(), value.end(), [](const auto &value) { return SVGLength::canConstruct(value); });
-}
-
-folly::dynamic SVGStrokeDashArray::toDynamic() const {
-  folly::dynamic array = folly::dynamic::array;
-  array.reserve(values.size());
-  for (const auto &value : values) {
-    array.push_back(value.toDynamic());
-  }
-  return array;
-}
-
-std::string SVGStrokeDashArray::toString() const {
-  std::stringstream ss;
-  ss << "{";
-  for (const auto &value : values) {
-    ss << value.toString();
-    if (&value != &values.back()) {
-      ss << ", ";
-    }
-  }
-  ss << "}";
-  return ss.str();
-}
-
-SVGStrokeDashArray SVGStrokeDashArray::interpolate(double progress, const SVGStrokeDashArray &to) const {
-  std::vector<SVGLength> result;
+SVGStrokeDashArray SVGStrokeDashArray::interpolate(
+    double progress,
+    const SVGStrokeDashArray &to,
+    const ResolvableValueInterpolationContext &context) const {
+  std::vector<CSSLength> result;
   auto fromValues = values;
   auto toValues = to.values;
 
@@ -89,14 +32,19 @@ SVGStrokeDashArray SVGStrokeDashArray::interpolate(double progress, const SVGStr
   result.reserve(resultSize);
 
   for (size_t i = 0; i < resultSize; i++) {
-    result.emplace_back(fromValues[i % fromSize].interpolate(progress, toValues[i % toSize]));
+    result.emplace_back(fromValues[i % fromSize].interpolate(progress, toValues[i % toSize], context));
   }
 
   return SVGStrokeDashArray(result);
 }
 
-bool SVGStrokeDashArray::operator==(const SVGStrokeDashArray &other) const {
-  return values == other.values;
+folly::dynamic SVGStrokeDashArray::toDynamic() const {
+  // Empty means "no dashing" - emit null instead of [], which react-native-svg
+  // would feed to Android's DashPathEffect that requires at least 2 intervals.
+  if (values.empty()) {
+    return nullptr;
+  }
+  return CSSLengthVector::toDynamic();
 }
 
 #ifndef NDEBUG

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/svg/values/SVGStrokeDashArray.h

@@ -1,29 +1,18 @@
 #pragma once
 
-#include <reanimated/CSS/svg/values/SVGLength.h>
-
-#include <numeric>
-#include <string>
-#include <vector>
+#include <reanimated/CSS/svg/values/CSSLengthVector.h>
 
 namespace reanimated::css {
 
-struct SVGStrokeDashArray : public CSSSimpleValue<SVGStrokeDashArray> {
-  std::vector<SVGLength> values;
-
-  SVGStrokeDashArray();
-  explicit SVGStrokeDashArray(const std::vector<SVGLength> &values);
-  explicit SVGStrokeDashArray(jsi::Runtime &rt, const jsi::Value &jsiValue);
-  explicit SVGStrokeDashArray(const folly::dynamic &value);
+struct SVGStrokeDashArray : public CSSLengthVector<SVGStrokeDashArray> {
+  using CSSLengthVector::CSSLengthVector;
 
-  static bool canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue);
-  static bool canConstruct(const folly::dynamic &value);
+  SVGStrokeDashArray interpolate(
+      double progress,
+      const SVGStrokeDashArray &to,
+      const ResolvableValueInterpolationContext &context) const override;
 
   folly::dynamic toDynamic() const override;
-  std::string toString() const override;
-  SVGStrokeDashArray interpolate(double progress, const SVGStrokeDashArray &to) const override;
-
-  bool operator==(const SVGStrokeDashArray &other) const;
 
 #ifndef NDEBUG
   friend std::ostream &operator<<(std::ostream &os, const SVGStrokeDashArray &strokeDashArray);

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/utils/platform.cpp

@@ -0,0 +1,284 @@
+#include <reanimated/CSS/utils/platform.h>
+
+#if __APPLE__
+
+#include <reanimated/CSS/utils/props.h>
+#include <reanimated/Tools/FeatureFlags.h>
+
+#include <array>
+#include <cstdint>
+#include <unordered_map>
+
+namespace reanimated::css {
+
+using namespace facebook;
+
+namespace {
+
+enum class CSSValueKind : std::uint8_t { Scalar, Color, Size };
+
+struct CSSPropertyTraits {
+  CSSValueKind kind;
+  // CSS-spec default applied when an endpoint is null.
+  PlatformValue defaultValue;
+};
+
+// The natively animatable properties: each one's value kind and CSS default
+// (mirrors InterpolatorRegistry.cpp). Grows as more properties are routed.
+const CSSPropertyTraits *traitsFor(const std::string &propertyName) {
+  constexpr std::array<double, 4> kTransparentColor = {0, 0, 0, 0};
+  constexpr std::array<double, 4> kBlackColor = {0, 0, 0, 1};
+  static const std::unordered_map<std::string, CSSPropertyTraits> kProperties = {
+      {"opacity", {CSSValueKind::Scalar, 1.0}},
+      {"backgroundColor", {CSSValueKind::Color, kTransparentColor}},
+      {"borderColor", {CSSValueKind::Color, kBlackColor}},
+      {"borderRadius", {CSSValueKind::Scalar, 0.0}},
+      {"borderWidth", {CSSValueKind::Scalar, 0.0}},
+      {"shadowColor", {CSSValueKind::Color, kBlackColor}},
+      {"shadowOpacity", {CSSValueKind::Scalar, 1.0}},
+      {"shadowRadius", {CSSValueKind::Scalar, 0.0}},
+      {"shadowOffset", {CSSValueKind::Size, std::array<double, 2>{0.0, 0.0}}},
+  };
+  const auto it = kProperties.find(propertyName);
+  return it != kProperties.end() ? &it->second : nullptr;
+}
+
+// RN's processColor encodes named colors and rgba() strings as a packed ARGB
+// number; PlatformColor-like objects are not expressible.
+PlatformValue parseColorNumber(const double number) {
+  const auto channels = extractColorChannels(static_cast<int64_t>(number));
+  return std::array<double, 4>{
+      channels[0] / 255.0,
+      channels[1] / 255.0,
+      channels[2] / 255.0,
+      channels[3] / 255.0,
+  };
+}
+
+} // namespace
+
+bool canRouteCSSProperty(const std::string &propertyName, const EasingConfig &easing) {
+  if constexpr (!StaticFeatureFlags::getFlag("IOS_CSS_CORE_ANIMATION")) {
+    return false;
+  }
+  if (traitsFor(propertyName) == nullptr) {
+    return false;
+  }
+  // TODO: border props route unconditionally, but snap when RN rasterizes the
+  // border (view fails useCoreAnimationBorderRendering); they should route only
+  // when the platform can render them correctly (follow-up PR).
+  // CAMediaTimingFunction can express only linear and cubic-bezier curves;
+  // steps / linear-stops easings have to interpolate per-frame on the loop.
+  return std::holds_alternative<LinearEasing>(easing) || std::holds_alternative<CubicBezierEasing>(easing);
+}
+
+std::optional<PlatformValue>
+parsePlatformValue(jsi::Runtime &rt, const std::string &propertyName, const jsi::Value &value) {
+  const auto *traits = traitsFor(propertyName);
+  if (traits == nullptr) {
+    return std::nullopt;
+  }
+  if (value.isNull() || value.isUndefined()) {
+    return traits->defaultValue;
+  }
+  switch (traits->kind) {
+    case CSSValueKind::Scalar:
+      return value.isNumber() ? std::optional<PlatformValue>(value.asNumber()) : std::nullopt;
+    case CSSValueKind::Color:
+      return value.isNumber() ? std::optional<PlatformValue>(parseColorNumber(value.asNumber())) : std::nullopt;
+    case CSSValueKind::Size: {
+      if (!value.isObject()) {
+        return std::nullopt;
+      }
+      const auto object = value.asObject(rt);
+      const auto width = object.getProperty(rt, "width");
+      const auto height = object.getProperty(rt, "height");
+      return std::array<double, 2>{
+          width.isNumber() ? width.asNumber() : 0.0,
+          height.isNumber() ? height.asNumber() : 0.0,
+      };
+    }
+  }
+  return std::nullopt;
+}
+
+std::optional<PlatformValue> parsePlatformValue(const std::string &propertyName, const folly::dynamic &value) {
+  const auto *traits = traitsFor(propertyName);
+  if (traits == nullptr) {
+    return std::nullopt;
+  }
+  if (value.isNull()) {
+    return traits->defaultValue;
+  }
+  switch (traits->kind) {
+    case CSSValueKind::Scalar:
+      return value.isNumber() ? std::optional<PlatformValue>(value.asDouble()) : std::nullopt;
+    case CSSValueKind::Color:
+      return value.isNumber() ? std::optional<PlatformValue>(parseColorNumber(value.asDouble())) : std::nullopt;
+    case CSSValueKind::Size: {
+      if (!value.isObject()) {
+        return std::nullopt;
+      }
+      const auto *width = value.get_ptr("width");
+      const auto *height = value.get_ptr("height");
+      return std::array<double, 2>{
+          width != nullptr && width->isNumber() ? width->asDouble() : 0.0,
+          height != nullptr && height->isNumber() ? height->asDouble() : 0.0,
+      };
+    }
+  }
+  return std::nullopt;
+}
+
+} // namespace reanimated::css
+
+#elif defined(__OHOS__) // __OHOS__
+
+#include <reanimated/CSS/utils/props.h>
+#include <reanimated/Tools/FeatureFlags.h>
+
+#include <array>
+#include <cstdint>
+#include <unordered_map>
+
+namespace reanimated::css {
+
+using namespace facebook;
+
+namespace {
+
+enum class CSSValueKind : std::uint8_t { Scalar, Color, Size };
+
+struct CSSPropertyTraits {
+  CSSValueKind kind;
+  // CSS-spec default applied when an endpoint is null.
+  PlatformValue defaultValue;
+};
+
+// The natively animatable properties: each one's value kind and CSS default
+// (mirrors InterpolatorRegistry.cpp). Grows as more properties are routed.
+//
+// Compared to the Apple table, the shadow* family is absent: ArkUI's
+// NODE_SHADOW takes only predefined style enums (no arbitrary
+// offset/radius/color), so shadows keep interpolating on the loop.
+const CSSPropertyTraits *traitsFor(const std::string &propertyName) {
+  constexpr std::array<double, 4> kTransparentColor = {0, 0, 0, 0};
+  constexpr std::array<double, 4> kBlackColor = {0, 0, 0, 1};
+  static const std::unordered_map<std::string, CSSPropertyTraits> kProperties = {
+      {"opacity", {CSSValueKind::Scalar, 1.0}},
+      {"backgroundColor", {CSSValueKind::Color, kTransparentColor}},
+      {"borderColor", {CSSValueKind::Color, kBlackColor}},
+      {"borderRadius", {CSSValueKind::Scalar, 0.0}},
+      {"borderWidth", {CSSValueKind::Scalar, 0.0}},
+  };
+  const auto it = kProperties.find(propertyName);
+  return it != kProperties.end() ? &it->second : nullptr;
+}
+
+// RN's processColor encodes named colors and rgba() strings as a packed ARGB
+// number; PlatformColor-like objects are not expressible.
+PlatformValue parseColorNumber(const double number) {
+  const auto channels = extractColorChannels(static_cast<int64_t>(number));
+  return std::array<double, 4>{
+      channels[0] / 255.0,
+      channels[1] / 255.0,
+      channels[2] / 255.0,
+      channels[3] / 255.0,
+  };
+}
+
+} // namespace
+
+bool canRouteCSSProperty(const std::string &propertyName, const EasingConfig &easing) {
+  if constexpr (!StaticFeatureFlags::getFlag("IOS_CSS_CORE_ANIMATION")) {
+    return false;
+  }
+  if (traitsFor(propertyName) == nullptr) {
+    return false;
+  }
+  // ArkUI curves express linear and cubic-bezier; steps / linear-stops
+  // easings have to interpolate per-frame on the loop.
+  return std::holds_alternative<LinearEasing>(easing) || std::holds_alternative<CubicBezierEasing>(easing);
+}
+
+std::optional<PlatformValue>
+parsePlatformValue(jsi::Runtime &rt, const std::string &propertyName, const jsi::Value &value) {
+  const auto *traits = traitsFor(propertyName);
+  if (traits == nullptr) {
+    return std::nullopt;
+  }
+  if (value.isNull() || value.isUndefined()) {
+    return traits->defaultValue;
+  }
+  switch (traits->kind) {
+    case CSSValueKind::Scalar:
+      return value.isNumber() ? std::optional<PlatformValue>(value.asNumber()) : std::nullopt;
+    case CSSValueKind::Color:
+      return value.isNumber() ? std::optional<PlatformValue>(parseColorNumber(value.asNumber())) : std::nullopt;
+    case CSSValueKind::Size: {
+      if (!value.isObject()) {
+        return std::nullopt;
+      }
+      const auto object = value.asObject(rt);
+      const auto width = object.getProperty(rt, "width");
+      const auto height = object.getProperty(rt, "height");
+      return std::array<double, 2>{
+          width.isNumber() ? width.asNumber() : 0.0,
+          height.isNumber() ? height.asNumber() : 0.0,
+      };
+    }
+  }
+  return std::nullopt;
+}
+
+std::optional<PlatformValue> parsePlatformValue(const std::string &propertyName, const folly::dynamic &value) {
+  const auto *traits = traitsFor(propertyName);
+  if (traits == nullptr) {
+    return std::nullopt;
+  }
+  if (value.isNull()) {
+    return traits->defaultValue;
+  }
+  switch (traits->kind) {
+    case CSSValueKind::Scalar:
+      return value.isNumber() ? std::optional<PlatformValue>(value.asDouble()) : std::nullopt;
+    case CSSValueKind::Color:
+      return value.isNumber() ? std::optional<PlatformValue>(parseColorNumber(value.asDouble())) : std::nullopt;
+    case CSSValueKind::Size: {
+      if (!value.isObject()) {
+        return std::nullopt;
+      }
+      const auto *width = value.get_ptr("width");
+      const auto *height = value.get_ptr("height");
+      return std::array<double, 2>{
+          width != nullptr && width->isNumber() ? width->asDouble() : 0.0,
+          height != nullptr && height->isNumber() ? height->asDouble() : 0.0,
+      };
+    }
+  }
+  return std::nullopt;
+}
+
+} // namespace reanimated::css
+
+#else // !__APPLE__ && !__OHOS__
+
+namespace reanimated::css {
+
+// No native routing backend on this platform yet; every property runs on the loop.
+bool canRouteCSSProperty(const std::string &, const EasingConfig &) {
+  return false;
+}
+
+std::optional<PlatformValue>
+parsePlatformValue(facebook::jsi::Runtime &, const std::string &, const facebook::jsi::Value &) {
+  return std::nullopt;
+}
+
+std::optional<PlatformValue> parsePlatformValue(const std::string &, const folly::dynamic &) {
+  return std::nullopt;
+}
+
+} // namespace reanimated::css
+
+#endif // __APPLE__

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/utils/platform.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <reanimated/CSS/easing/EasingConfigs.h>
+
+#include <folly/dynamic.h>
+#include <jsi/jsi.h>
+
+#include <array>
+#include <optional>
+#include <string>
+#include <variant>
+
+namespace reanimated::css {
+
+/// The value kinds the platform can animate natively: scalars, sizes, and RGBA
+/// colors (normalized to [0, 1]).
+using PlatformValue = std::variant<double, std::array<double, 2>, std::array<double, 4>>;
+
+/// Whether the property can animate natively for the given easing. Routing is
+/// platform specific: platforms without a native backend (e.g. Android) never
+/// route, so every property runs on the C++ loop.
+bool canRouteCSSProperty(const std::string &propertyName, const EasingConfig &easing);
+
+/// Parses a transition endpoint into a platform value. Null/undefined falls back
+/// to the property's CSS default; nullopt means it can't be animated natively and
+/// runs on the loop. Two overloads: jsi::Value (config) and folly::dynamic (toggle).
+std::optional<PlatformValue>
+parsePlatformValue(facebook::jsi::Runtime &rt, const std::string &propertyName, const facebook::jsi::Value &value);
+std::optional<PlatformValue> parsePlatformValue(const std::string &propertyName, const folly::dynamic &value);
+
+} // namespace reanimated::css