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

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/core/transition/CSSTransition.cpp

@@ -0,0 +1,97 @@
+#include <reanimated/CSS/core/transition/CSSLoopTransition.h>
+#include <reanimated/CSS/core/transition/CSSTransition.h>
+#include <reanimated/Fabric/updates/OperationsLoop.h>
+
+#include <memory>
+#include <utility>
+
+namespace reanimated::css {
+
+CSSTransition::CSSTransition(
+    std::shared_ptr<const ShadowNode> shadowNode,
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository,
+    const std::shared_ptr<CSSPlatformTransitionProxy> &platformTransitionProxy,
+    const std::shared_ptr<OperationsLoop> &loop,
+    Observer &observer)
+    : shadowNode_(std::move(shadowNode)),
+      viewStylesRepository_(viewStylesRepository),
+      platformTransitionProxy_(platformTransitionProxy),
+      loop_(loop),
+      observer_(observer) {}
+
+CSSTransition::~CSSTransition() {
+  platformTransitionProxy_->cancelAll(getViewTag(), routing_.platform);
+}
+
+TransitionProperties CSSTransition::getProperties() const {
+  TransitionProperties result = routing_.loop;
+  result.insert(routing_.platform.begin(), routing_.platform.end());
+  return result;
+}
+
+folly::dynamic CSSTransition::run(jsi::Runtime &rt, CSSTransitionConfig &&config, const folly::dynamic &lastUpdates) {
+  const auto timestamp = loop_->resolveTimestamp();
+
+  auto loopConfig = platformTransitionProxy_->processConfig(rt, getViewTag(), config, routing_, timestamp);
+  if (loopConfig.empty()) {
+    return folly::dynamic::object();
+  }
+
+  auto &loopTransition = ensureLoopTransition();
+  loopTransition.updateSettings(loopConfig.changedPropertiesSettings, loopConfig.removedProperties);
+
+  // Settings-only configs reconfigure without running.
+  if (!loopConfig.hasValueUpdates()) {
+    return folly::dynamic::object();
+  }
+
+  auto initialUpdate = loopTransition.run(rt, shadowNode_, loopConfig.changedProperties, lastUpdates, timestamp);
+  scheduleLoop(timestamp);
+  return initialUpdate;
+}
+
+folly::dynamic CSSTransition::run(
+    const PropertyValueDynamicDiffsMap &propertyDiffs,
+    const folly::dynamic &lastUpdates) {
+  const auto timestamp = loop_->resolveTimestamp();
+
+  auto loopDiffs = platformTransitionProxy_->processDynamicDiffs(getViewTag(), propertyDiffs, routing_, timestamp);
+  if (loopDiffs.empty() && !loopTransition_) {
+    return folly::dynamic::object();
+  }
+
+  auto initialUpdate = ensureLoopTransition().run(shadowNode_, loopDiffs, lastUpdates, timestamp);
+  scheduleLoop(timestamp);
+  return initialUpdate;
+}
+
+folly::dynamic CSSTransition::computeCurrentLoopStyle() {
+  if (!loopTransition_) {
+    return folly::dynamic::object();
+  }
+  return loopTransition_->computeCurrentStyle(shadowNode_);
+}
+
+void CSSTransition::cancel() {
+  if (loopTransition_) {
+    loop_->remove(loopTransition_);
+  }
+  platformTransitionProxy_->cancelAll(getViewTag(), routing_.platform);
+}
+
+CSSLoopTransition &CSSTransition::ensureLoopTransition() {
+  if (!loopTransition_) {
+    loopTransition_ = std::make_shared<CSSLoopTransition>(
+        shadowNode_->getTag(),
+        shadowNode_->getComponentName(),
+        viewStylesRepository_,
+        [&observer = observer_](Tag viewTag) { observer.onTransitionUpdate(viewTag); });
+  }
+  return *loopTransition_;
+}
+
+void CSSTransition::scheduleLoop(const double timestamp) {
+  loop_->schedule(loopTransition_, timestamp + loopTransition_->getMinDelay(timestamp));
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/core/transition/CSSTransition.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <reanimated/CSS/configs/CSSTransitionConfig.h>
+#include <reanimated/CSS/core/transition/CSSLoopTransition.h>
+#include <reanimated/CSS/core/transition/CSSPlatformTransitionProxy.h>
+#include <reanimated/CSS/misc/ViewStylesRepository.h>
+#include <reanimated/Fabric/updates/OperationsLoop.h>
+
+#include <react/renderer/core/ShadowNode.h>
+
+#include <folly/dynamic.h>
+#include <jsi/jsi.h>
+#include <memory>
+
+namespace reanimated::css {
+
+class CSSTransition {
+ public:
+  class Observer {
+   public:
+    virtual ~Observer() = default;
+    virtual void onTransitionUpdate(Tag viewTag) = 0;
+  };
+
+  CSSTransition(
+      std::shared_ptr<const ShadowNode> shadowNode,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository,
+      const std::shared_ptr<CSSPlatformTransitionProxy> &platformTransitionProxy,
+      const std::shared_ptr<OperationsLoop> &loop,
+      Observer &observer);
+  ~CSSTransition();
+
+  Tag getViewTag() const {
+    return shadowNode_->getTag();
+  }
+
+  std::shared_ptr<const ShadowNode> getShadowNode() const {
+    return shadowNode_;
+  }
+
+  ShadowNodeFamily::Shared getShadowNodeFamily() const {
+    return shadowNode_->getFamilyShared();
+  }
+
+  TransitionProperties getProperties() const;
+
+  folly::dynamic computeCurrentLoopStyle();
+
+  /// Applies a config: routes props between the platform and loop sides and runs them.
+  folly::dynamic run(jsi::Runtime &rt, CSSTransitionConfig &&config, const folly::dynamic &lastUpdates);
+  /// Runs the loop side directly from already-computed (dynamic) diffs.
+  folly::dynamic run(const PropertyValueDynamicDiffsMap &propertyDiffs, const folly::dynamic &lastUpdates);
+  void cancel();
+
+ private:
+  const std::shared_ptr<const ShadowNode> shadowNode_;
+  const std::shared_ptr<ViewStylesRepository> viewStylesRepository_;
+  const std::shared_ptr<CSSPlatformTransitionProxy> platformTransitionProxy_;
+  const std::shared_ptr<OperationsLoop> loop_;
+  Observer &observer_;
+
+  CSSTransitionRouting routing_;
+  std::shared_ptr<CSSLoopTransition> loopTransition_;
+
+  CSSLoopTransition &ensureLoopTransition();
+  void scheduleLoop(double timestamp);
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/easing/EasingConfigs.cpp

@@ -0,0 +1,89 @@
+#include <reanimated/CSS/easing/EasingConfigs.h>
+#include <reanimated/CSS/easing/cubicBezier.h>
+#include <reanimated/CSS/easing/linear.h>
+#include <reanimated/CSS/easing/steps.h>
+
+#include <stdexcept>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+
+namespace reanimated::css {
+
+EasingFunction getEasingFunctionFromConfig(const EasingConfig &easingConfig) {
+  return std::visit(
+      [](const auto &config) -> EasingFunction {
+        using T = std::decay_t<decltype(config)>;
+        if constexpr (std::is_same_v<T, LinearEasing>) {
+          return [](double x) {
+            return x;
+          };
+        } else if constexpr (std::is_same_v<T, CubicBezierEasing>) {
+          return cubicBezier(config.x1, config.y1, config.x2, config.y2);
+        } else if constexpr (std::is_same_v<T, StepsEasing>) {
+          return steps(config.pointsX, config.pointsY);
+        } else {
+          return linear(config.pointsX, config.pointsY);
+        }
+      },
+      easingConfig);
+}
+
+EasingConfig getEasingConfig(jsi::Runtime &rt, const jsi::Value &easingConfig) {
+  static const std::unordered_map<std::string, EasingConfig> PREDEFINED_EASING_CONFIGS = {
+      {"linear", LinearEasing{}},
+      {"ease", CubicBezierEasing{0.25, 0.1, 0.25, 1.0}},
+      {"ease-in", CubicBezierEasing{0.42, 0.0, 1.0, 1.0}},
+      {"ease-out", CubicBezierEasing{0.0, 0.0, 0.58, 1.0}},
+      {"ease-in-out", CubicBezierEasing{0.42, 0.0, 0.58, 1.0}},
+      {"step-start", StepsEasing{{0}, {1}}},
+      {"step-end", StepsEasing{{0, 1}, {0, 1}}}};
+
+  if (easingConfig.isString()) {
+    const auto easingName = easingConfig.asString(rt).utf8(rt);
+    const auto easingIt = PREDEFINED_EASING_CONFIGS.find(easingName);
+    if (easingIt != PREDEFINED_EASING_CONFIGS.end()) {
+      return easingIt->second;
+    }
+    throw std::runtime_error("[Reanimated] Easing function with name '" + easingName + "' is not defined.");
+  }
+
+  if (easingConfig.isObject()) {
+    const auto easingObj = easingConfig.asObject(rt);
+    const auto easingName = easingObj.getProperty(rt, "name").asString(rt).utf8(rt);
+    if (easingName == "cubicBezier") {
+      return CubicBezierEasing{
+          easingObj.getProperty(rt, "x1").asNumber(),
+          easingObj.getProperty(rt, "y1").asNumber(),
+          easingObj.getProperty(rt, "x2").asNumber(),
+          easingObj.getProperty(rt, "y2").asNumber()};
+    }
+
+    std::vector<double> pointsX;
+    std::vector<double> pointsY;
+
+    const auto points = easingObj.getProperty(rt, "points").asObject(rt).asArray(rt);
+    const auto pointsCount = points.size(rt);
+    pointsX.reserve(pointsCount);
+    pointsY.reserve(pointsCount);
+
+    for (size_t i = 0; i < pointsCount; i++) {
+      const auto pointObj = points.getValueAtIndex(rt, i).asObject(rt);
+      pointsX.emplace_back(pointObj.getProperty(rt, "x").asNumber());
+      pointsY.emplace_back(pointObj.getProperty(rt, "y").asNumber());
+    }
+
+    if (easingName == "linear") {
+      return LinearStopsEasing{std::move(pointsX), std::move(pointsY)};
+    }
+    if (easingName == "steps") {
+      return StepsEasing{std::move(pointsX), std::move(pointsY)};
+    }
+    throw std::runtime_error(
+        "[Reanimated] Parametrized easing function with name '" + easingName + "' is not defined.");
+  }
+
+  throw std::runtime_error("[Reanimated] Invalid easing function");
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/easing/EasingConfigs.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <reanimated/CSS/easing/EasingFunctions.h>
+
+#include <jsi/jsi.h>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+namespace reanimated::css {
+
+struct LinearEasing {};
+
+struct CubicBezierEasing {
+  double x1, y1, x2, y2;
+};
+
+struct StepsEasing {
+  std::vector<double> pointsX;
+  std::vector<double> pointsY;
+};
+
+struct LinearStopsEasing {
+  std::vector<double> pointsX;
+  std::vector<double> pointsY;
+};
+
+using EasingConfig = std::variant<LinearEasing, CubicBezierEasing, StepsEasing, LinearStopsEasing>;
+
+using KeyframeEasingConfigs = std::unordered_map<double, EasingConfig>;
+
+EasingConfig getEasingConfig(jsi::Runtime &rt, const jsi::Value &easingConfig);
+EasingFunction getEasingFunctionFromConfig(const EasingConfig &easingConfig);
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/InterpolatorFactory.cpp

@@ -33,6 +33,10 @@ class RecordInterpolatorFactory : public PropertyInterpolatorFactory {
     std::string toString() const override {
       return "{}";
     }
+
+    bool operator==(const CSSValue &) const override {
+      return false;
+    }
   };
 
   const InterpolatorFactoriesRecord factories_;
@@ -55,6 +59,10 @@ class ArrayLikeInterpolatorFactory : public PropertyInterpolatorFactory {
     std::string toString() const override {
       return "[]";
     }
+
+    bool operator==(const CSSValue &) const override {
+      return false;
+    }
   };
 };
 
@@ -119,6 +127,10 @@ class TransformsInterpolatorFactory : public PropertyInterpolatorFactory {
     std::string toString() const override {
       return getIdentityMatrix().toString();
     }
+
+    bool operator==(const CSSValue &) const override {
+      return false;
+    }
   };
 
   const std::shared_ptr<StyleOperationInterpolators> interpolators_;

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

@@ -112,6 +112,11 @@ template <typename... AllowedTypes>
 auto value(const auto &defaultValue) -> std::enable_if_t<
     (std::is_constructible_v<AllowedTypes, decltype(defaultValue)> || ...),
     std::shared_ptr<PropertyInterpolatorFactory>> {
+  static_assert(
+      !(Resolvable<AllowedTypes> || ...),
+      "Resolvable value types (e.g. CSSLength) require a "
+      "ResolvableValueInterpolatorConfig — use the value(defaultValue, "
+      "{RelativeTo::..., \"...\"}) overload instead");
   // Create a concrete CSSValue from the defaultValue
   auto cssValue = createCSSValue<AllowedTypes...>(defaultValue);
   return std::make_shared<SimpleValueInterpolatorFactory<AllowedTypes...>>(std::move(cssValue));
@@ -121,6 +126,10 @@ template <typename... AllowedTypes>
 auto value(const auto &defaultValue, ResolvableValueInterpolatorConfig config) -> std::enable_if_t<
     (std::is_constructible_v<AllowedTypes, decltype(defaultValue)> || ...),
     std::shared_ptr<PropertyInterpolatorFactory>> {
+  static_assert(
+      (Resolvable<AllowedTypes> || ...),
+      "None of the value types are resolvable — use the value(defaultValue) "
+      "overload without ResolvableValueInterpolatorConfig instead");
   // Create a concrete CSSValue from the defaultValue
   auto cssValue = createCSSValue<AllowedTypes...>(defaultValue);
   return std::make_shared<ResolvableValueInterpolatorFactory<AllowedTypes...>>(std::move(cssValue), std::move(config));
@@ -181,8 +190,8 @@ std::shared_ptr<PropertyInterpolatorFactory> transforms(
     const std::unordered_map<std::string, std::shared_ptr<StyleOperationInterpolator>> &interpolators);
 
 /**
-* Filter interpolators
-*/
+ * Filter interpolators
+ */
 std::shared_ptr<PropertyInterpolatorFactory> filters(
     const std::unordered_map<std::string, std::shared_ptr<StyleOperationInterpolator>> &interpolators);
 

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/PropertyInterpolator.cpp

@@ -1,6 +1,5 @@
 #include <reanimated/CSS/interpolation/PropertyInterpolator.h>
-
-#include <worklets/Tools/JSISerializer.h>
+#include <reanimated/Compat/WorkletsApi.h>
 
 #include <memory>
 #include <utility>
@@ -35,7 +34,7 @@ std::vector<std::pair<double, jsi::Value>> PropertyInterpolator::parseJSIKeyfram
     throw std::invalid_argument(
         "[Reanimated] Received invalid keyframes object for property: " + getPropertyPathString() +
         ".\n\nExpected an array of objects with 'offset' and 'value' properties, got: " +
-        worklets::stringifyJSIValue(rt, keyframes));
+        worklets::JSIValueToStdString(rt, keyframes));
   }
 
   const auto keyframeArray = keyframes.asObject(rt).asArray(rt);

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

@@ -23,13 +23,11 @@ class PropertyInterpolator {
   virtual folly::dynamic getResetStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const = 0;
   virtual folly::dynamic getFirstKeyframeValue() const = 0;
   virtual folly::dynamic getLastKeyframeValue() const = 0;
-  virtual bool equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const = 0;
 
   virtual void updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) = 0;
-  virtual void updateKeyframesFromStyleChange(
-      const folly::dynamic &oldStyleValue,
-      const folly::dynamic &newStyleValue,
-      const folly::dynamic &lastUpdateValue) = 0;
+  virtual bool updateKeyframes(jsi::Runtime &rt, const jsi::Value &fromValue, const jsi::Value &toValue) = 0;
+  /** TODO: unify folly::dynamic and jsi::value versions */
+  virtual bool updateKeyframes(const folly::dynamic &fromValue, const folly::dynamic &toValue) = 0;
 
   virtual folly::dynamic interpolate(
       const std::shared_ptr<const ShadowNode> &shadowNode,

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/filters/FilterOperation.cpp

@@ -108,16 +108,16 @@ std::shared_ptr<FilterOperation> FilterOperation::fromDynamic(const folly::dynam
 }
 
 // FilterOperationBase implementation
-template <FilterOp TOperation, typename  TValue>
+template <FilterOp TOperation, CSSValueDerived TValue>
 FilterOperationBase<TOperation, TValue>::FilterOperationBase(TValue value)
     : FilterOperation(TOperation), value(std::move(value)) {}
 
-template <FilterOp TOperation, typename  TValue>
+template <FilterOp TOperation, CSSValueDerived TValue>
 folly::dynamic FilterOperationBase<TOperation, TValue>::valueToDynamic() const {
   return value.toDynamic();
 }
 
-template <FilterOp TOperation, typename  TValue>
+template <FilterOp TOperation, CSSValueDerived TValue>
 bool FilterOperationBase<TOperation, TValue>::areValuesEqual(const StyleOperation &other) const {
   return value == static_cast<const FilterOperationBase<TOperation, TValue> &>(other).value;
 }

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/filters/FilterOperation.h

@@ -26,7 +26,7 @@ struct FilterOperation : public StyleOperation {
 using FilterOperations = std::vector<std::shared_ptr<FilterOperation>>;
 
 // Base implementation for filter operations
-template <FilterOp TOperation, typename  TValue>
+template <FilterOp TOperation, CSSValueDerived TValue>
 struct FilterOperationBase : public FilterOperation {
   const TValue value;
 

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/groups/ArrayPropertiesInterpolator.cpp

@@ -11,25 +11,6 @@ ArrayPropertiesInterpolator::ArrayPropertiesInterpolator(
     const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
     : GroupPropertiesInterpolator(propertyPath, viewStylesRepository), factories_(factories) {}
 
-bool ArrayPropertiesInterpolator::equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const {
-  if (!propertyValue.isArray()) {
-    return false;
-  }
-
-  const auto valuesCount = propertyValue.size();
-  if (valuesCount != interpolators_.size()) {
-    return false;
-  }
-
-  for (size_t i = 0; i < valuesCount; ++i) {
-    if (!interpolators_[i]->equalsReversingAdjustedStartValue(propertyValue[i])) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
 void ArrayPropertiesInterpolator::updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) {
   const jsi::Array keyframesArray = keyframes.asObject(rt).asArray(rt);
   const size_t valuesCount = keyframesArray.size(rt);
@@ -41,32 +22,52 @@ void ArrayPropertiesInterpolator::updateKeyframes(jsi::Runtime &rt, const jsi::V
   }
 }
 
-void ArrayPropertiesInterpolator::updateKeyframesFromStyleChange(
-    const folly::dynamic &oldStyleValue,
-    const folly::dynamic &newStyleValue,
-    const folly::dynamic &lastUpdateValue) {
-  const auto emptyArray = folly::dynamic::array();
-  const auto null = folly::dynamic();
+bool ArrayPropertiesInterpolator::updateKeyframes(
+    jsi::Runtime &rt,
+    const jsi::Value &fromValue,
+    const jsi::Value &toValue) {
+  const auto fromArray = fromValue.isUndefined() ? jsi::Array(rt, 0) : fromValue.asObject(rt).asArray(rt);
+  const auto toArray = toValue.isUndefined() ? jsi::Array(rt, 0) : toValue.asObject(rt).asArray(rt);
 
-  const auto &oldStyleArray = oldStyleValue.empty() ? emptyArray : oldStyleValue;
-  const auto &newStyleArray = newStyleValue.empty() ? emptyArray : newStyleValue;
-  const auto &lastUpdateArray = lastUpdateValue.empty() ? emptyArray : lastUpdateValue;
-
-  const size_t oldSize = oldStyleArray.size();
-  const size_t newSize = newStyleArray.size();
-  const size_t lastSize = lastUpdateArray.size();
-  const size_t valuesCount = std::max(oldSize, newSize);
+  const size_t fromSize = fromArray.size(rt);
+  const size_t toSize = toArray.size(rt);
+  const size_t valuesCount = std::max(fromSize, toSize);
 
   resizeInterpolators(valuesCount);
 
+  bool areAllPropsReversed = true;
+
   for (size_t i = 0; i < valuesCount; ++i) {
     // These index checks ensure that interpolation works between 2 arrays
     // with different lengths
-    interpolators_[i]->updateKeyframesFromStyleChange(
-        i < oldSize ? oldStyleArray[i] : null,
-        i < newSize ? newStyleArray[i] : null,
-        i < lastSize ? lastUpdateArray[i] : null);
+    areAllPropsReversed &= interpolators_[i]->updateKeyframes(
+        rt,
+        i < fromSize ? fromArray.getValueAtIndex(rt, i) : jsi::Value::undefined(),
+        i < toSize ? toArray.getValueAtIndex(rt, i) : jsi::Value::undefined());
   }
+
+  return areAllPropsReversed;
+}
+
+bool ArrayPropertiesInterpolator::updateKeyframes(const folly::dynamic &fromValue, const folly::dynamic &toValue) {
+  const auto fromIsArray = fromValue.isArray();
+  const auto toIsArray = toValue.isArray();
+
+  const size_t fromSize = fromIsArray ? fromValue.size() : 0;
+  const size_t toSize = toIsArray ? toValue.size() : 0;
+  const size_t valuesCount = std::max(fromSize, toSize);
+
+  resizeInterpolators(valuesCount);
+
+  bool areAllPropsReversed = true;
+
+  static const folly::dynamic kNull;
+  for (size_t i = 0; i < valuesCount; ++i) {
+    areAllPropsReversed &=
+        interpolators_[i]->updateKeyframes(i < fromSize ? fromValue[i] : kNull, i < toSize ? toValue[i] : kNull);
+  }
+
+  return areAllPropsReversed;
 }
 
 folly::dynamic ArrayPropertiesInterpolator::mapInterpolators(

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/groups/ArrayPropertiesInterpolator.h

@@ -15,13 +15,10 @@ class ArrayPropertiesInterpolator : public GroupPropertiesInterpolator {
       const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
   virtual ~ArrayPropertiesInterpolator() = default;
 
-  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;
 
  protected:
   folly::dynamic mapInterpolators(const std::function<folly::dynamic(PropertyInterpolator &)> &callback) const override;

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/groups/RecordPropertiesInterpolator.cpp

@@ -12,21 +12,6 @@ RecordPropertiesInterpolator::RecordPropertiesInterpolator(
     const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
     : GroupPropertiesInterpolator(propertyPath, viewStylesRepository), factories_(factories) {}
 
-bool RecordPropertiesInterpolator::equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const {
-//  return std::ranges::all_of(propertyValue.items(), [this](const auto &item) {
-//    const auto &[propName, propValue] = item;
-//    const auto it = interpolators_.find(propName.getString());
-//    return it != interpolators_.end() && it->second->equalsReversingAdjustedStartValue(propValue);
-//  });
-     //TODO
-    return std::all_of(propertyValue.items().begin(), propertyValue.items().end(), [this](const auto &item) {
-        const auto &[propName, propValue] = item;
-        const auto it = interpolators_.find(propName.getString());
-        return it != interpolators_.end() &&
-            it->second->equalsReversingAdjustedStartValue(propValue);
-    });
-}
-
 void RecordPropertiesInterpolator::updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) {
   // TODO - maybe add a possibility to remove interpolators that are no longer
   // used (for now, for simplicity, we only add new ones)
@@ -44,34 +29,71 @@ void RecordPropertiesInterpolator::updateKeyframes(jsi::Runtime &rt, const jsi::
   }
 }
 
-void RecordPropertiesInterpolator::updateKeyframesFromStyleChange(
-    const folly::dynamic &oldStyleValue,
-    const folly::dynamic &newStyleValue,
-    const folly::dynamic &lastUpdateValue) {
+bool RecordPropertiesInterpolator::updateKeyframes(
+    jsi::Runtime &rt,
+    const jsi::Value &fromValue,
+    const jsi::Value &toValue) {
   // TODO - maybe add a possibility to remove interpolators that are no longer
   // used (for now, for simplicity, we only add new ones)
-  const folly::dynamic emptyObject = folly::dynamic::object();
-  const auto null = folly::dynamic();
+  const auto fromObject = fromValue.isUndefined() ? jsi::Object(rt) : fromValue.asObject(rt);
+  const auto toObject = toValue.isUndefined() ? jsi::Object(rt) : toValue.asObject(rt);
+
+  const auto fromPropertyNames = fromObject.getPropertyNames(rt);
+  const auto toPropertyNames = toObject.getPropertyNames(rt);
+  const auto fromSize = fromPropertyNames.size(rt);
+  const auto toSize = toPropertyNames.size(rt);
+
+  std::unordered_set<std::string> propertyNamesSet;
+  for (size_t i = 0; i < fromSize; ++i) {
+    propertyNamesSet.insert(fromPropertyNames.getValueAtIndex(rt, i).asString(rt).utf8(rt));
+  }
+  for (size_t i = 0; i < toSize; ++i) {
+    propertyNamesSet.insert(toPropertyNames.getValueAtIndex(rt, i).asString(rt).utf8(rt));
+  }
+
+  bool areAllPropsReversed = true;
+
+  for (const auto &propertyName : propertyNamesSet) {
+    maybeCreateInterpolator(propertyName);
+    const auto propNameID = jsi::PropNameID::forUtf8(rt, propertyName);
+    areAllPropsReversed &= interpolators_[propertyName]->updateKeyframes(
+        rt,
+        fromObject.hasProperty(rt, propNameID) ? fromObject.getProperty(rt, propNameID) : jsi::Value::undefined(),
+        toObject.hasProperty(rt, propNameID) ? toObject.getProperty(rt, propNameID) : jsi::Value::undefined());
+  }
 
-  const auto &oldStyleObject = oldStyleValue.empty() ? emptyObject : oldStyleValue;
-  const auto &newStyleObject = newStyleValue.empty() ? emptyObject : newStyleValue;
-  const auto &lastUpdateObject = lastUpdateValue.empty() ? emptyObject : lastUpdateValue;
+  return areAllPropsReversed;
+}
+
+bool RecordPropertiesInterpolator::updateKeyframes(const folly::dynamic &fromValue, const folly::dynamic &toValue) {
+  // TODO - maybe add a possibility to remove interpolators that are no longer
+  // used (for now, for simplicity, we only add new ones)
+  const auto fromIsObject = fromValue.isObject();
+  const auto toIsObject = toValue.isObject();
 
   std::unordered_set<std::string> propertyNamesSet;
-  for (const auto &key : oldStyleObject.keys()) {
-    propertyNamesSet.insert(key.asString());
+  if (fromIsObject) {
+    for (const auto &item : fromValue.items()) {
+      propertyNamesSet.insert(item.first.asString());
+    }
   }
-  for (const auto &key : newStyleObject.keys()) {
-    propertyNamesSet.insert(key.asString());
+  if (toIsObject) {
+    for (const auto &item : toValue.items()) {
+      propertyNamesSet.insert(item.first.asString());
+    }
   }
 
+  bool areAllPropsReversed = true;
+
+  static const folly::dynamic kNull;
   for (const auto &propertyName : propertyNamesSet) {
     maybeCreateInterpolator(propertyName);
-    interpolators_[propertyName]->updateKeyframesFromStyleChange(
-        oldStyleObject.getDefault(propertyName, null),
-        newStyleObject.getDefault(propertyName, null),
-        lastUpdateObject.getDefault(propertyName, null));
+    areAllPropsReversed &= interpolators_[propertyName]->updateKeyframes(
+        fromIsObject && fromValue.count(propertyName) ? fromValue[propertyName] : kNull,
+        toIsObject && toValue.count(propertyName) ? toValue[propertyName] : kNull);
   }
+
+  return areAllPropsReversed;
 }
 
 folly::dynamic RecordPropertiesInterpolator::mapInterpolators(