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

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

@@ -196,7 +196,10 @@ folly::dynamic TransformOperationBase<TOperation, TValue>::valueToDynamic() cons
 
 template <TransformOp TOperation, typename TValue>
 bool TransformOperationBase<TOperation, TValue>::areValuesEqual(const StyleOperation &other) const {
-  return value == static_cast<const TransformOperationBase<TOperation, TValue> &>(other).value;
+  if (typeid(*this) == typeid(other)) {
+    return value == static_cast<const TransformOperationBase<TOperation, TValue> &>(other).value;
+  }
+  return false;
 }
 
 // Rotate operations

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

@@ -5,13 +5,15 @@
 #include <reanimated/CSS/interpolation/transforms/operations/skew.h>
 #include <reanimated/CSS/interpolation/transforms/operations/translate.h>
 
+#include <cmath>
+#include <limits>
 #include <utility>
 
 namespace reanimated::css {
 
 // Base implementation for simple operations
-template <typename TOperation, typename TEnable>
-std::unique_ptr<StyleOperation> TransformOperationInterpolator<TOperation, TEnable>::interpolate(
+template <typename TOperation>
+std::unique_ptr<StyleOperation> TransformOperationInterpolator<TOperation>::interpolate(
     double progress,
     const std::shared_ptr<StyleOperation> &from,
     const std::shared_ptr<StyleOperation> &to,
@@ -22,33 +24,38 @@ std::unique_ptr<StyleOperation> TransformOperationInterpolator<TOperation, TEnab
 }
 
 // Specialization for PerspectiveOperation
-TransformOperationInterpolator<PerspectiveOperation, void>::TransformOperationInterpolator(
+TransformOperationInterpolator<PerspectiveOperation>::TransformOperationInterpolator(
     const std::shared_ptr<PerspectiveOperation> &defaultOperation)
     : StyleOperationInterpolator(defaultOperation) {}
 
-std::unique_ptr<StyleOperation> TransformOperationInterpolator<PerspectiveOperation, void>::interpolate(
+std::unique_ptr<StyleOperation> TransformOperationInterpolator<PerspectiveOperation>::interpolate(
     double progress,
     const std::shared_ptr<StyleOperation> &from,
     const std::shared_ptr<StyleOperation> &to,
     const StyleOperationsInterpolationContext & /* context */) const {
-  // TODO - check if this implementation is correct
   const auto &fromValue = std::static_pointer_cast<PerspectiveOperation>(from)->value;
   const auto &toValue = std::static_pointer_cast<PerspectiveOperation>(to)->value;
 
-  if (fromValue.value == 0)
-    return std::make_unique<PerspectiveOperation>(toValue);
-  if (toValue.value == 0)
-    return std::make_unique<PerspectiveOperation>(fromValue);
+  // The default "no perspective" is infinity, so interpolating the distance
+  // directly gives inf + t*(d - inf) = NaN. Interpolate in reciprocal space
+  // instead (1/inf = 0, matching how perspective enters the matrix as -1/d).
+  if (std::isinf(fromValue.value) || std::isinf(toValue.value)) {
+    const double fromReciprocal = 1.0 / fromValue.value;
+    const double toReciprocal = 1.0 / toValue.value;
+    const double reciprocal = fromReciprocal + progress * (toReciprocal - fromReciprocal);
+    return std::make_unique<PerspectiveOperation>(
+        reciprocal == 0.0 ? std::numeric_limits<double>::infinity() : 1.0 / reciprocal);
+  }
 
   return std::make_unique<PerspectiveOperation>(fromValue.interpolate(progress, toValue));
 }
 
 // Specialization for MatrixOperation
-TransformOperationInterpolator<MatrixOperation, void>::TransformOperationInterpolator(
+TransformOperationInterpolator<MatrixOperation>::TransformOperationInterpolator(
     const std::shared_ptr<MatrixOperation> &defaultOperation)
     : StyleOperationInterpolator(defaultOperation) {}
 
-std::unique_ptr<StyleOperation> TransformOperationInterpolator<MatrixOperation, void>::interpolate(
+std::unique_ptr<StyleOperation> TransformOperationInterpolator<MatrixOperation>::interpolate(
     double progress,
     const std::shared_ptr<StyleOperation> &from,
     const std::shared_ptr<StyleOperation> &to,
@@ -73,7 +80,7 @@ std::unique_ptr<StyleOperation> TransformOperationInterpolator<MatrixOperation,
 }
 
 template <typename MatrixType>
-MatrixType TransformOperationInterpolator<MatrixOperation, void>::interpolateMatrix(
+MatrixType TransformOperationInterpolator<MatrixOperation>::interpolateMatrix(
     double progress,
     const TransformMatrix::Shared &from,
     const TransformMatrix::Shared &to) const {
@@ -89,7 +96,7 @@ MatrixType TransformOperationInterpolator<MatrixOperation, void>::interpolateMat
   return MatrixType::recompose(decomposedFrom->interpolate(progress, decomposedTo.value()));
 }
 
-TransformMatrix::Shared TransformOperationInterpolator<MatrixOperation, void>::matrixFromOperation(
+TransformMatrix::Shared TransformOperationInterpolator<MatrixOperation>::matrixFromOperation(
     const std::shared_ptr<TransformOperation> &operation,
     const bool shouldBe3D,
     const StyleOperationsInterpolationContext &context) const {
@@ -132,84 +139,34 @@ TransformMatrix::Shared TransformOperationInterpolator<MatrixOperation, void>::m
 }
 
 // Explicit template instantiations
-template TransformMatrix2D TransformOperationInterpolator<MatrixOperation, void>::interpolateMatrix<TransformMatrix2D>(
+template TransformMatrix2D TransformOperationInterpolator<MatrixOperation>::interpolateMatrix<TransformMatrix2D>(
     double,
     const TransformMatrix::Shared &,
     const TransformMatrix::Shared &) const;
-template TransformMatrix3D TransformOperationInterpolator<MatrixOperation, void>::interpolateMatrix<TransformMatrix3D>(
+template TransformMatrix3D TransformOperationInterpolator<MatrixOperation>::interpolateMatrix<TransformMatrix3D>(
     double,
     const TransformMatrix::Shared &,
     const TransformMatrix::Shared &) const;
 
-// Specialization for resolvable operations
-template <typename TOperation>
-TransformOperationInterpolator<
-    TOperation,
-    std::enable_if_t<ResolvableOp<TOperation> && !std::is_same_v<TOperation, PerspectiveOperation> && !std::is_same_v<TOperation, MatrixOperation>>>::TransformOperationInterpolator(
-    const std::shared_ptr<TOperation> &defaultOperation,
-    ResolvableValueInterpolatorConfig config)
-    : StyleOperationInterpolator(defaultOperation), config_(std::move(config)) {}
-
-template <typename TOperation>
-std::unique_ptr<StyleOperation> TransformOperationInterpolator<
-    TOperation,
-    std::enable_if_t<ResolvableOp<TOperation> && !std::is_same_v<TOperation, PerspectiveOperation> && !std::is_same_v<TOperation, MatrixOperation>>>::interpolate(
-    double progress,
-    const std::shared_ptr<StyleOperation> &from,
-    const std::shared_ptr<StyleOperation> &to,
-    const StyleOperationsInterpolationContext &context) const {
-  const auto &fromOp = *std::static_pointer_cast<TOperation>(from);
-  const auto &toOp = *std::static_pointer_cast<TOperation>(to);
-
-  return std::make_unique<TOperation>(
-      fromOp.value.interpolate(progress, toOp.value, getResolvableValueContext(context)));
-}
-
-template <typename TOperation>
-std::shared_ptr<StyleOperation> TransformOperationInterpolator<
-    TOperation,
-    std::enable_if_t<ResolvableOp<TOperation> && !std::is_same_v<TOperation, PerspectiveOperation> && !std::is_same_v<TOperation, MatrixOperation>>>::resolveOperation(
-    const std::shared_ptr<StyleOperation> &operation,
-    const StyleOperationsInterpolationContext &context) const {
-  const auto &resolvableOp = std::static_pointer_cast<TOperation>(operation);
-  const auto &resolved = resolvableOp->value.resolve(getResolvableValueContext(context));
-
-  if (!resolved.has_value()) {
-    throw std::invalid_argument(
-        "[Reanimated] Cannot resolve resolvable operation: " + operation->getOperationName() +
-        " for node with tag: " + std::to_string(context.node->getTag()));
-  }
-
-  return std::make_shared<TOperation>(resolved.value());
-}
-
-template <typename TOperation>
-ResolvableValueInterpolationContext TransformOperationInterpolator<
-    TOperation,
-    std::enable_if_t<ResolvableOp<TOperation> && !std::is_same_v<TOperation, PerspectiveOperation> && !std::is_same_v<TOperation, MatrixOperation>>>::getResolvableValueContext(
-    const StyleOperationsInterpolationContext &context) const {
-  return ResolvableValueInterpolationContext{
-      .node = context.node,
-      .fallbackInterpolateThreshold = context.fallbackInterpolateThreshold,
-      .viewStylesRepository = context.viewStylesRepository,
-      .relativeProperty = config_.relativeProperty,
-      .relativeTo = config_.relativeTo};
-}
+// OHOS patch: the members of the ResolvableOp-constrained partial
+// specialization are defined inline in the header (clang 15 can't match their
+// out-of-line definitions with the specialization declaration). Only the
+// explicit instantiations remain here.
 
 // Rotate operations
-template class TransformOperationInterpolator<RotateOperation, void>;
-template class TransformOperationInterpolator<RotateXOperation, void>;
-template class TransformOperationInterpolator<RotateYOperation, void>;
-template class TransformOperationInterpolator<RotateZOperation, void>;
+template class TransformOperationInterpolator<RotateOperation>;
+template class TransformOperationInterpolator<RotateXOperation>;
+template class TransformOperationInterpolator<RotateYOperation>;
+template class TransformOperationInterpolator<RotateZOperation>;
 
 // Scale operations
-template class TransformOperationInterpolator<ScaleOperation, void>;
-template class TransformOperationInterpolator<ScaleXOperation, void>;
-template class TransformOperationInterpolator<ScaleYOperation, void>;
+template class TransformOperationInterpolator<ScaleOperation>;
+template class TransformOperationInterpolator<ScaleXOperation>;
+template class TransformOperationInterpolator<ScaleYOperation>;
 
 // Skew operations
-template class TransformOperationInterpolator<SkewXOperation, void>;
-template class TransformOperationInterpolator<SkewYOperation, void>;
+template class TransformOperationInterpolator<SkewXOperation>;
+template class TransformOperationInterpolator<SkewYOperation>;
 
 // Translate operations (resolvable)
 template class TransformOperationInterpolator<TranslateXOperation>;

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

@@ -6,12 +6,13 @@
 #include <reanimated/CSS/interpolation/transforms/operations/perspective.h>
 
 #include <memory>
-#include <type_traits>
+#include <stdexcept>
+#include <string>
 
 namespace reanimated::css {
-    
+
 // Base implementation for simple operations
-template <typename TOperation, typename = void>
+template <typename TOperation>
 class TransformOperationInterpolator : public StyleOperationInterpolator {
  public:
   using StyleOperationInterpolator::StyleOperationInterpolator;
@@ -25,7 +26,7 @@ class TransformOperationInterpolator : public StyleOperationInterpolator {
 
 // Specialization for PerspectiveOperation
 template <>
-class TransformOperationInterpolator<PerspectiveOperation, void> : public StyleOperationInterpolator {
+class TransformOperationInterpolator<PerspectiveOperation> : public StyleOperationInterpolator {
  public:
   explicit TransformOperationInterpolator(const std::shared_ptr<PerspectiveOperation> &defaultOperation);
 
@@ -38,7 +39,7 @@ class TransformOperationInterpolator<PerspectiveOperation, void> : public StyleO
 
 // Specialization for MatrixOperation
 template <>
-class TransformOperationInterpolator<MatrixOperation, void> : public StyleOperationInterpolator {
+class TransformOperationInterpolator<MatrixOperation> : public StyleOperationInterpolator {
  public:
   explicit TransformOperationInterpolator(const std::shared_ptr<MatrixOperation> &defaultOperation);
 
@@ -60,30 +61,60 @@ class TransformOperationInterpolator<MatrixOperation, void> : public StyleOperat
 };
 
 // Specialization for resolvable operations
-template <typename TOperation>
-class TransformOperationInterpolator<
-    TOperation,
-    std::enable_if_t<ResolvableOp<TOperation> && !std::is_same_v<TOperation, PerspectiveOperation> && !std::is_same_v<TOperation, MatrixOperation>>> : public StyleOperationInterpolator {
+// OHOS patch: clang 15 (the OHOS NDK toolchain) fails to match out-of-line
+// member definitions of a concept-constrained partial specialization with the
+// specialization's declaration — it resolves them against the primary template
+// instead ("type constraint differs in template redeclaration" followed by
+// "member initializer 'config_' does not name a non-static data member").
+// Upstream defines these members out-of-line in the .cpp; here they are moved
+// inline. Semantics are unchanged.
+template <ResolvableOp TOperation>
+class TransformOperationInterpolator<TOperation> : public StyleOperationInterpolator {
  public:
   TransformOperationInterpolator(
       const std::shared_ptr<TOperation> &defaultOperation,
-      ResolvableValueInterpolatorConfig config);
+      ResolvableValueInterpolatorConfig config)
+      : StyleOperationInterpolator(defaultOperation), config_(std::move(config)) {}
 
   std::unique_ptr<StyleOperation> interpolate(
       double progress,
       const std::shared_ptr<StyleOperation> &from,
       const std::shared_ptr<StyleOperation> &to,
-      const StyleOperationsInterpolationContext &context) const override;
+      const StyleOperationsInterpolationContext &context) const override {
+    const auto &fromOp = *std::static_pointer_cast<TOperation>(from);
+    const auto &toOp = *std::static_pointer_cast<TOperation>(to);
+
+    return std::make_unique<TOperation>(
+        fromOp.value.interpolate(progress, toOp.value, getResolvableValueContext(context)));
+  }
 
   std::shared_ptr<StyleOperation> resolveOperation(
       const std::shared_ptr<StyleOperation> &operation,
-      const StyleOperationsInterpolationContext &context) const override;
+      const StyleOperationsInterpolationContext &context) const override {
+    const auto &resolvableOp = std::static_pointer_cast<TOperation>(operation);
+    const auto &resolved = resolvableOp->value.resolve(getResolvableValueContext(context));
+
+    if (!resolved.has_value()) {
+      throw std::invalid_argument(
+          "[Reanimated] Cannot resolve resolvable operation: " + operation->getOperationName() +
+          " for node with tag: " + std::to_string(context.node->getTag()));
+    }
+
+    return std::make_shared<TOperation>(resolved.value());
+  }
 
  protected:
   const ResolvableValueInterpolatorConfig config_;
 
   ResolvableValueInterpolationContext getResolvableValueContext(
-      const StyleOperationsInterpolationContext &context) const;
+      const StyleOperationsInterpolationContext &context) const {
+    return ResolvableValueInterpolationContext{
+        .node = context.node,
+        .fallbackInterpolateThreshold = context.fallbackInterpolateThreshold,
+        .viewStylesRepository = context.viewStylesRepository,
+        .relativeProperty = config_.relativeProperty,
+        .relativeTo = config_.relativeTo};
+  }
 };
 
 } // namespace reanimated::css

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

@@ -60,26 +60,28 @@ std::pair<TransformOperations, bool> flattenOperations(const TransformOperations
  * operations can be converted to a matrix.
  */
 std::pair<MatrixOperationValue, bool> simplifyOperations(const TransformOperations &operations) {
-  const auto [flattenedOperations, is3D] = flattenOperations(operations);
+  // OHOS patch: clang 15 doesn't allow capturing a structured binding in a
+  // lambda (P1091 fully landed in clang 16), and the `simplify` lambda below
+  // reads `is3D`. Read the pair through plain local references instead; they
+  // alias the same objects so semantics/perf are unchanged.
+  const auto flattenResult = flattenOperations(operations);
+  const auto &flattenedOperations = flattenResult.first;
+  const auto &is3D = flattenResult.second;
 
   TransformOperations result;
   TransformOperations toSimplify;
   result.reserve(operations.size());
   toSimplify.reserve(operations.size());
 
-//  const auto simplify = [&]() {
-//    return is3D ? std::make_shared<MatrixOperation>(matrixFromOperations3D(toSimplify))
-//                : std::make_shared<MatrixOperation>(matrixFromOperations2D(toSimplify));
-//  };
-   //TODO
-  const auto simplify = [](TransformOperations &toSimplify,bool is3DValue) {
-    return is3DValue ? std::make_shared<MatrixOperation>(matrixFromOperations3D(toSimplify))
+  const auto simplify = [&]() {
+    return is3D ? std::make_shared<MatrixOperation>(matrixFromOperations3D(toSimplify))
                 : std::make_shared<MatrixOperation>(matrixFromOperations2D(toSimplify));
   };
+
   for (const auto &operation : flattenedOperations) {
     if (operation->shouldResolve()) {
       if (toSimplify.size() > 0) {
-        result.emplace_back(simplify(toSimplify,is3D));
+        result.emplace_back(simplify());
         toSimplify.clear();
       }
 
@@ -94,10 +96,10 @@ std::pair<MatrixOperationValue, bool> simplifyOperations(const TransformOperatio
   // Result is empty only if there was not a single operation that needed to be
   // resolved (all operations were added to the toSimplify vector)
   if (result.empty()) {
-    return {simplify(toSimplify,is3D)->toMatrix(is3D), is3D};
+    return {simplify()->toMatrix(is3D), is3D};
   }
 
-  result.emplace_back(simplify(toSimplify,is3D));
+  result.emplace_back(simplify());
 
   return {std::move(result), is3D};
 }

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

@@ -7,6 +7,8 @@
 #include <reanimated/CSS/common/values/CSSKeyword.h>
 #include <reanimated/CSS/common/values/CSSLength.h>
 #include <reanimated/CSS/common/values/CSSNumber.h>
+#include <reanimated/CSS/svg/values/CSSLengthArray.h>
+#include <reanimated/CSS/svg/values/SVGStrokeDashArray.h>
 
 #include <memory>
 
@@ -43,5 +45,7 @@ folly::dynamic ResolvableValueInterpolator<AllowedTypes...>::interpolateValue(
 
 template class ResolvableValueInterpolator<CSSLength>;
 template class ResolvableValueInterpolator<CSSLength, CSSKeyword>;
+template class ResolvableValueInterpolator<CSSLengthArray>;
+template class ResolvableValueInterpolator<SVGStrokeDashArray, CSSKeyword>;
 
 } // namespace reanimated::css

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

@@ -11,8 +11,10 @@
 #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/CSSLengthArray.h>
 #include <reanimated/CSS/svg/values/SVGBrush.h>
-#include <reanimated/CSS/svg/values/SVGLength.h>
+#include <reanimated/CSS/svg/values/SVGPath.h>
+#include <reanimated/CSS/svg/values/SVGStops.h>
 #include <reanimated/CSS/svg/values/SVGStrokeDashArray.h>
 
 #include <memory>
@@ -54,6 +56,7 @@ template class SimpleValueInterpolator<CSSLength, CSSKeyword>;
 template class SimpleValueInterpolator<CSSDouble>;
 template class SimpleValueInterpolator<CSSDouble, CSSKeyword>;
 template class SimpleValueInterpolator<CSSInteger>;
+template class SimpleValueInterpolator<CSSIndex>;
 template class SimpleValueInterpolator<CSSAngle>;
 template class SimpleValueInterpolator<CSSColor>;
 template class SimpleValueInterpolator<CSSBoolean>;
@@ -62,8 +65,9 @@ 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<SVGPath>;
+template class SimpleValueInterpolator<CSSLengthArray>;
+template class SimpleValueInterpolator<SVGStops>;
 template class SimpleValueInterpolator<SVGStrokeDashArray, CSSKeyword>;
 template class SimpleValueInterpolator<SVGBrush>;
 

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

@@ -35,13 +35,6 @@ 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);
 
@@ -57,28 +50,28 @@ void ValueInterpolator::updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyf
   }
 }
 
-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_};
-  }
+bool ValueInterpolator::updateKeyframes(jsi::Runtime &rt, const jsi::Value &fromValue, const jsi::Value &toValue) {
+  auto from = fromValue.isUndefined() ? defaultStyleValue_ : createValue(rt, fromValue);
+  auto to = toValue.isUndefined() ? defaultStyleValue_ : createValue(rt, toValue);
 
-  if (newStyleValue.isNull()) {
-    lastKeyframe = ValueKeyframe{1, defaultStyleValue_};
-  } else {
-    lastKeyframe = ValueKeyframe{1, createValue(newStyleValue)};
-  }
+  const auto equalsReversingAdjustedStartValue = reversingAdjustedStartValue_ && (*to == *reversingAdjustedStartValue_);
+  reversingAdjustedStartValue_ = keyframes_.empty() ? from : keyframes_[1].value.value();
+
+  keyframes_ = {ValueKeyframe{0, std::move(from)}, ValueKeyframe{1, std::move(to)}};
+
+  return equalsReversingAdjustedStartValue;
+}
+
+bool ValueInterpolator::updateKeyframes(const folly::dynamic &fromValue, const folly::dynamic &toValue) {
+  auto from = fromValue.isNull() ? defaultStyleValue_ : createValue(fromValue);
+  auto to = toValue.isNull() ? defaultStyleValue_ : createValue(toValue);
+
+  const auto equalsReversingAdjustedStartValue = reversingAdjustedStartValue_ && (*to == *reversingAdjustedStartValue_);
+  reversingAdjustedStartValue_ = keyframes_.empty() ? from : keyframes_[1].value.value();
+
+  keyframes_ = {ValueKeyframe{0, std::move(from)}, ValueKeyframe{1, std::move(to)}};
 
-  keyframes_ = {std::move(firstKeyframe), std::move(lastKeyframe)};
-  reversingAdjustedStartValue_ = oldStyleValue;
+  return equalsReversingAdjustedStartValue;
 }
 
 folly::dynamic ValueInterpolator::interpolate(

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

@@ -10,11 +10,15 @@
 namespace reanimated::css {
 
 struct ValueKeyframe {
+  // OHOS patch: explicit constructor for the same reason as
+  // SVGStops::GradientStop — clang 15's is_constructible trait misses
+  // parenthesized aggregate init (P0960), which breaks
+  // keyframes_.emplace_back(offset, ...) in ValueInterpolator.cpp.
+  ValueKeyframe(double offset_, std::optional<std::shared_ptr<CSSValue>> value_)
+      : offset(offset_), value(std::move(value_)) {}
+
   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)) {}            
 };
 
 /**
@@ -35,13 +39,11 @@ class ValueInterpolator : public PropertyInterpolator {
   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;
+  bool updateKeyframes(jsi::Runtime &rt, const jsi::Value &fromValue, const jsi::Value &toValue) override;
+  /** TODO: unify folly::dynamic and jsi::value versions */
+  bool updateKeyframes(const folly::dynamic &fromValue, const folly::dynamic &toValue) override;
 
   folly::dynamic interpolate(
       const std::shared_ptr<const ShadowNode> &shadowNode,
@@ -52,7 +54,6 @@ class ValueInterpolator : public PropertyInterpolator {
   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;
@@ -63,6 +64,8 @@ class ValueInterpolator : public PropertyInterpolator {
       const ValueInterpolationContext &context) const = 0;
 
  private:
+  std::shared_ptr<CSSValue> reversingAdjustedStartValue_;
+
   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;