@react-native-ohos/react-native-reanimated 3.18.2-rc.2 → 4.0.1

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

@@ -0,0 +1,38 @@
+#include <reanimated/CSS/interpolation/filters/FilterOperationInterpolator.h>
+
+#include <reanimated/CSS/interpolation/filters/operations/blur.h>
+#include <reanimated/CSS/interpolation/filters/operations/brightness.h>
+#include <reanimated/CSS/interpolation/filters/operations/contrast.h>
+#include <reanimated/CSS/interpolation/filters/operations/dropShadow.h>
+#include <reanimated/CSS/interpolation/filters/operations/grayscale.h>
+#include <reanimated/CSS/interpolation/filters/operations/hueRotate.h>
+#include <reanimated/CSS/interpolation/filters/operations/invert.h>
+#include <reanimated/CSS/interpolation/filters/operations/opacity.h>
+#include <reanimated/CSS/interpolation/filters/operations/saturate.h>
+#include <reanimated/CSS/interpolation/filters/operations/sepia.h>
+
+namespace reanimated::css {
+
+template <typename TOperation>
+std::unique_ptr<StyleOperation> FilterOperationInterpolator<TOperation>::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));
+}
+
+template class FilterOperationInterpolator<BlurOperation>;
+template class FilterOperationInterpolator<BrightnessOperation>;
+template class FilterOperationInterpolator<ContrastOperation>;
+template class FilterOperationInterpolator<DropShadowOperation>;
+template class FilterOperationInterpolator<GrayscaleOperation>;
+template class FilterOperationInterpolator<HueRotateOperation>;
+template class FilterOperationInterpolator<InvertOperation>;
+template class FilterOperationInterpolator<OpacityOperation>;
+template class FilterOperationInterpolator<SaturateOperation>;
+template class FilterOperationInterpolator<SepiaOperation>;
+
+} // namespace reanimated::css

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

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <reanimated/CSS/common/filters/FilterOp.h>
+#include <reanimated/CSS/interpolation/configs.h>
+#include <reanimated/CSS/interpolation/filters/FilterOperation.h>
+#include <reanimated/CSS/interpolation/operations/StyleOperationInterpolator.h>
+
+#include <memory>
+
+namespace reanimated::css {
+
+template <typename TOperation>
+class FilterOperationInterpolator final : public StyleOperationInterpolator {
+ public:
+  using StyleOperationInterpolator::StyleOperationInterpolator;
+
+  std::unique_ptr<StyleOperation> interpolate(
+      double progress,
+      const std::shared_ptr<StyleOperation> &from,
+      const std::shared_ptr<StyleOperation> &to,
+      const StyleOperationsInterpolationContext &context) const override;
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,58 @@
+#include <reanimated/CSS/interpolation/filters/FilterStyleInterpolator.h>
+
+#include <algorithm>
+#include <memory>
+#include <optional>
+#include <utility>
+
+namespace reanimated::css {
+
+const folly::dynamic defaultStyleValueDynamic = folly::dynamic::array();
+
+FilterStyleInterpolator::FilterStyleInterpolator(
+    const PropertyPath &propertyPath,
+    const std::shared_ptr<StyleOperationInterpolators> &interpolators,
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
+    : OperationsStyleInterpolatorBase<FilterOperation>(
+          propertyPath,
+          interpolators,
+          viewStylesRepository,
+          defaultStyleValueDynamic) {}
+
+std::optional<std::pair<StyleOperations, StyleOperations>> FilterStyleInterpolator::createInterpolationPair(
+    const StyleOperations &fromOperations,
+    const StyleOperations &toOperations) const {
+  StyleOperations fromOperationsResult, toOperationsResult;
+  size_t i = 0;
+
+  size_t fromOperationsSize = fromOperations.size();
+  size_t toOperationsSize = toOperations.size();
+  size_t minSize = std::min(fromOperationsSize, toOperationsSize);
+
+  for (; i < minSize; i++) {
+    const auto &fromOperation = fromOperations[i];
+    const auto &toOperation = toOperations[i];
+
+    // Types don't match, we need to return nullopt as we cannot interpolate
+    if (fromOperation->type != toOperation->type) {
+      return std::nullopt;
+    }
+
+    fromOperationsResult.emplace_back(fromOperation);
+    toOperationsResult.emplace_back(toOperation);
+  }
+
+  // Add remaining operations with default values
+  for (; i < fromOperations.size(); ++i) {
+    fromOperationsResult.emplace_back(fromOperations[i]);
+    toOperationsResult.emplace_back(getDefaultOperationOfType(fromOperations[i]->type));
+  }
+  for (; i < toOperations.size(); ++i) {
+    fromOperationsResult.emplace_back(getDefaultOperationOfType(toOperations[i]->type));
+    toOperationsResult.emplace_back(toOperations[i]);
+  }
+
+  return std::make_pair(fromOperationsResult, toOperationsResult);
+}
+
+} // namespace reanimated::css

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

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <reanimated/CSS/interpolation/filters/FilterOperation.h>
+#include <reanimated/CSS/interpolation/operations/OperationsStyleInterpolator.h>
+
+#include <memory>
+#include <utility>
+
+namespace reanimated::css {
+
+class FilterStyleInterpolator final : public OperationsStyleInterpolatorBase<FilterOperation> {
+ public:
+  FilterStyleInterpolator(
+      const PropertyPath &propertyPath,
+      const std::shared_ptr<StyleOperationInterpolators> &interpolators,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
+
+ protected:
+  std::optional<std::pair<StyleOperations, StyleOperations>> createInterpolationPair(
+      const StyleOperations &fromOperations,
+      const StyleOperations &toOperations) const override;
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSNumber.h>
+#include <reanimated/CSS/interpolation/filters/FilterOperation.h>
+
+namespace reanimated::css {
+
+struct BlurOperation final : public FilterOperationBase<FilterOp::Blur, CSSDouble> {
+  using FilterOperationBase<FilterOp::Blur, CSSDouble>::FilterOperationBase;
+
+  explicit BlurOperation(double value) : FilterOperationBase<FilterOp::Blur, CSSDouble>(CSSDouble(value)) {}
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSNumber.h>
+#include <reanimated/CSS/interpolation/filters/FilterOperation.h>
+
+namespace reanimated::css {
+
+struct BrightnessOperation final : public FilterOperationBase<FilterOp::Brightness, CSSDouble> {
+  using FilterOperationBase<FilterOp::Brightness, CSSDouble>::FilterOperationBase;
+
+  explicit BrightnessOperation(double value) : FilterOperationBase<FilterOp::Brightness, CSSDouble>(CSSDouble(value)) {}
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSNumber.h>
+#include <reanimated/CSS/interpolation/filters/FilterOperation.h>
+
+namespace reanimated::css {
+
+struct ContrastOperation final : public FilterOperationBase<FilterOp::Contrast, CSSDouble> {
+  using FilterOperationBase<FilterOp::Contrast, CSSDouble>::FilterOperationBase;
+
+  explicit ContrastOperation(double value) : FilterOperationBase<FilterOp::Contrast, CSSDouble>(CSSDouble(value)) {}
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/complex/CSSDropShadow.h>
+#include <reanimated/CSS/interpolation/filters/FilterOperation.h>
+
+#include <utility>
+
+namespace reanimated::css {
+
+struct DropShadowOperation final : public FilterOperationBase<FilterOp::DropShadow, CSSDropShadow> {
+  using FilterOperationBase<FilterOp::DropShadow, CSSDropShadow>::FilterOperationBase;
+
+  explicit DropShadowOperation(CSSDropShadow value)
+      : FilterOperationBase<FilterOp::DropShadow, CSSDropShadow>(std::move(value)) {}
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSNumber.h>
+#include <reanimated/CSS/interpolation/filters/FilterOperation.h>
+
+namespace reanimated::css {
+
+struct GrayscaleOperation final : public FilterOperationBase<FilterOp::Grayscale, CSSDouble> {
+  using FilterOperationBase<FilterOp::Grayscale, CSSDouble>::FilterOperationBase;
+
+  explicit GrayscaleOperation(double value) : FilterOperationBase<FilterOp::Grayscale, CSSDouble>(CSSDouble(value)) {}
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSNumber.h>
+#include <reanimated/CSS/interpolation/filters/FilterOperation.h>
+
+namespace reanimated::css {
+
+struct HueRotateOperation final : public FilterOperationBase<FilterOp::HueRotate, CSSDouble> {
+  using FilterOperationBase<FilterOp::HueRotate, CSSDouble>::FilterOperationBase;
+
+  explicit HueRotateOperation(double value) : FilterOperationBase<FilterOp::HueRotate, CSSDouble>(CSSDouble(value)) {}
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSNumber.h>
+#include <reanimated/CSS/interpolation/filters/FilterOperation.h>
+
+namespace reanimated::css {
+
+struct InvertOperation final : public FilterOperationBase<FilterOp::Invert, CSSDouble> {
+  using FilterOperationBase<FilterOp::Invert, CSSDouble>::FilterOperationBase;
+
+  explicit InvertOperation(double value) : FilterOperationBase<FilterOp::Invert, CSSDouble>(CSSDouble(value)) {}
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSNumber.h>
+#include <reanimated/CSS/interpolation/filters/FilterOperation.h>
+
+namespace reanimated::css {
+
+struct OpacityOperation final : public FilterOperationBase<FilterOp::Opacity, CSSDouble> {
+  using FilterOperationBase<FilterOp::Opacity, CSSDouble>::FilterOperationBase;
+
+  explicit OpacityOperation(double value) : FilterOperationBase<FilterOp::Opacity, CSSDouble>(CSSDouble(value)) {}
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSNumber.h>
+#include <reanimated/CSS/interpolation/filters/FilterOperation.h>
+
+namespace reanimated::css {
+
+struct SaturateOperation final : public FilterOperationBase<FilterOp::Saturate, CSSDouble> {
+  using FilterOperationBase<FilterOp::Saturate, CSSDouble>::FilterOperationBase;
+
+  explicit SaturateOperation(double value) : FilterOperationBase<FilterOp::Saturate, CSSDouble>(CSSDouble(value)) {}
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSNumber.h>
+#include <reanimated/CSS/interpolation/filters/FilterOperation.h>
+
+namespace reanimated::css {
+
+struct SepiaOperation final : public FilterOperationBase<FilterOp::Sepia, CSSDouble> {
+  using FilterOperationBase<FilterOp::Sepia, CSSDouble>::FilterOperationBase;
+
+  explicit SepiaOperation(double value) : FilterOperationBase<FilterOp::Sepia, CSSDouble>(CSSDouble(value)) {}
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,95 @@
+#include <reanimated/CSS/interpolation/groups/ArrayPropertiesInterpolator.h>
+
+#include <algorithm>
+#include <memory>
+
+namespace reanimated::css {
+
+ArrayPropertiesInterpolator::ArrayPropertiesInterpolator(
+    const InterpolatorFactoriesArray &factories,
+    const PropertyPath &propertyPath,
+    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);
+
+  resizeInterpolators(valuesCount);
+
+  for (size_t i = 0; i < valuesCount; ++i) {
+    interpolators_[i]->updateKeyframes(rt, keyframesArray.getValueAtIndex(rt, i));
+  }
+}
+
+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();
+
+  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);
+
+  resizeInterpolators(valuesCount);
+
+  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);
+  }
+}
+
+folly::dynamic ArrayPropertiesInterpolator::mapInterpolators(
+    const std::function<folly::dynamic(PropertyInterpolator &)> &callback) const {
+  auto result = folly::dynamic::array();
+
+  for (size_t i = 0; i < interpolators_.size(); ++i) {
+    result.push_back(callback(*interpolators_[i]));
+  }
+
+  return result;
+}
+
+void ArrayPropertiesInterpolator::resizeInterpolators(size_t valuesCount) {
+  // Remove excess interpolators if the array size has decreased
+  if (interpolators_.size() > valuesCount) {
+    interpolators_.resize(valuesCount);
+  }
+
+  while (interpolators_.size() < valuesCount) {
+    interpolators_.emplace_back(
+        createPropertyInterpolator(interpolators_.size(), propertyPath_, factories_, viewStylesRepository_));
+  }
+}
+
+} // namespace reanimated::css

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

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <reanimated/CSS/interpolation/groups/GroupPropertiesInterpolator.h>
+#include <reanimated/CSS/utils/interpolators.h>
+
+#include <memory>
+
+namespace reanimated::css {
+
+class ArrayPropertiesInterpolator : public GroupPropertiesInterpolator {
+ public:
+  ArrayPropertiesInterpolator(
+      const InterpolatorFactoriesArray &factories,
+      const PropertyPath &propertyPath,
+      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;
+
+ protected:
+  folly::dynamic mapInterpolators(const std::function<folly::dynamic(PropertyInterpolator &)> &callback) const override;
+
+ private:
+  const InterpolatorFactoriesArray &factories_;
+  PropertyInterpolatorsArray interpolators_;
+
+  void resizeInterpolators(size_t valuesCount);
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,41 @@
+#include <reanimated/CSS/interpolation/groups/GroupPropertiesInterpolator.h>
+
+#include <memory>
+
+namespace reanimated::css {
+
+GroupPropertiesInterpolator::GroupPropertiesInterpolator(
+    const PropertyPath &propertyPath,
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
+    : PropertyInterpolator(propertyPath, viewStylesRepository) {}
+
+folly::dynamic GroupPropertiesInterpolator::getStyleValue(const std::shared_ptr<const ShadowNode> &shadowNode) const {
+  return mapInterpolators(
+      [&](PropertyInterpolator &interpolator) -> folly::dynamic { return interpolator.getStyleValue(shadowNode); });
+}
+
+folly::dynamic GroupPropertiesInterpolator::getResetStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const {
+  return mapInterpolators(
+      [&](PropertyInterpolator &interpolator) -> folly::dynamic { return interpolator.getResetStyle(shadowNode); });
+}
+
+folly::dynamic GroupPropertiesInterpolator::getFirstKeyframeValue() const {
+  return mapInterpolators(
+      [&](PropertyInterpolator &interpolator) -> folly::dynamic { return interpolator.getFirstKeyframeValue(); });
+}
+
+folly::dynamic GroupPropertiesInterpolator::getLastKeyframeValue() const {
+  return mapInterpolators(
+      [&](PropertyInterpolator &interpolator) -> folly::dynamic { return interpolator.getLastKeyframeValue(); });
+}
+
+folly::dynamic GroupPropertiesInterpolator::interpolate(
+    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const std::shared_ptr<KeyframeProgressProvider> &progressProvider,
+    const double fallbackInterpolateThreshold) const {
+  return mapInterpolators([&](PropertyInterpolator &interpolator) -> folly::dynamic {
+    return interpolator.interpolate(shadowNode, progressProvider, fallbackInterpolateThreshold);
+  });
+}
+
+} // namespace reanimated::css

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

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <reanimated/CSS/interpolation/PropertyInterpolator.h>
+#include <reanimated/CSS/misc/ViewStylesRepository.h>
+#include <reanimated/CSS/progress/KeyframeProgressProvider.h>
+
+#include <memory>
+
+namespace reanimated::css {
+
+class GroupPropertiesInterpolator : public PropertyInterpolator {
+ public:
+  GroupPropertiesInterpolator(
+      const PropertyPath &propertyPath,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
+
+  folly::dynamic getStyleValue(const std::shared_ptr<const ShadowNode> &shadowNode) const override;
+  folly::dynamic getResetStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const override;
+  folly::dynamic getFirstKeyframeValue() const override;
+  folly::dynamic getLastKeyframeValue() const override;
+
+  folly::dynamic interpolate(
+      const std::shared_ptr<const ShadowNode> &shadowNode,
+      const std::shared_ptr<KeyframeProgressProvider> &progressProvider,
+      double fallbackInterpolateThreshold) const override;
+
+ protected:
+  virtual folly::dynamic mapInterpolators(
+      const std::function<folly::dynamic(PropertyInterpolator &)> &callback) const = 0;
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,99 @@
+#include <reanimated/CSS/interpolation/groups/RecordPropertiesInterpolator.h>
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+
+namespace reanimated::css {
+
+RecordPropertiesInterpolator::RecordPropertiesInterpolator(
+    const InterpolatorFactoriesRecord &factories,
+    const PropertyPath &propertyPath,
+    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)
+  const jsi::Object keyframesObject = keyframes.asObject(rt);
+
+  jsi::Array propertyNames = keyframesObject.getPropertyNames(rt);
+  size_t propertiesCount = propertyNames.size(rt);
+
+  for (size_t i = 0; i < propertiesCount; ++i) {
+    const std::string propertyName = propertyNames.getValueAtIndex(rt, i).asString(rt).utf8(rt);
+    const jsi::Value &propertyKeyframes = keyframesObject.getProperty(rt, jsi::PropNameID::forUtf8(rt, propertyName));
+
+    maybeCreateInterpolator(propertyName);
+    interpolators_[propertyName]->updateKeyframes(rt, propertyKeyframes);
+  }
+}
+
+void RecordPropertiesInterpolator::updateKeyframesFromStyleChange(
+    const folly::dynamic &oldStyleValue,
+    const folly::dynamic &newStyleValue,
+    const folly::dynamic &lastUpdateValue) {
+  // 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 &oldStyleObject = oldStyleValue.empty() ? emptyObject : oldStyleValue;
+  const auto &newStyleObject = newStyleValue.empty() ? emptyObject : newStyleValue;
+  const auto &lastUpdateObject = lastUpdateValue.empty() ? emptyObject : lastUpdateValue;
+
+  std::unordered_set<std::string> propertyNamesSet;
+  for (const auto &key : oldStyleObject.keys()) {
+    propertyNamesSet.insert(key.asString());
+  }
+  for (const auto &key : newStyleObject.keys()) {
+    propertyNamesSet.insert(key.asString());
+  }
+
+  for (const auto &propertyName : propertyNamesSet) {
+    maybeCreateInterpolator(propertyName);
+    interpolators_[propertyName]->updateKeyframesFromStyleChange(
+        oldStyleObject.getDefault(propertyName, null),
+        newStyleObject.getDefault(propertyName, null),
+        lastUpdateObject.getDefault(propertyName, null));
+  }
+}
+
+folly::dynamic RecordPropertiesInterpolator::mapInterpolators(
+    const std::function<folly::dynamic(PropertyInterpolator &)> &callback) const {
+  folly::dynamic result = folly::dynamic::object;
+
+  for (const auto &[propertyName, interpolator] : interpolators_) {
+    const auto value = callback(*interpolator);
+    if (!value.isNull()) {
+      result[propertyName] = value;
+    }
+  }
+
+  return result;
+}
+
+void RecordPropertiesInterpolator::maybeCreateInterpolator(const std::string &propertyName) {
+  if (interpolators_.find(propertyName) == interpolators_.end()) {
+    const auto newInterpolator =
+        createPropertyInterpolator(propertyName, propertyPath_, factories_, viewStylesRepository_);
+    interpolators_.emplace(propertyName, newInterpolator);
+  }
+}
+
+} // namespace reanimated::css

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

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <reanimated/CSS/interpolation/groups/GroupPropertiesInterpolator.h>
+#include <reanimated/CSS/utils/interpolators.h>
+
+#include <memory>
+#include <string>
+
+namespace reanimated::css {
+
+class RecordPropertiesInterpolator : public GroupPropertiesInterpolator {
+ public:
+  RecordPropertiesInterpolator(
+      const InterpolatorFactoriesRecord &factories,
+      const PropertyPath &propertyPath,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
+  virtual ~RecordPropertiesInterpolator() = 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;
+
+ protected:
+  folly::dynamic mapInterpolators(const std::function<folly::dynamic(PropertyInterpolator &)> &callback) const override;
+
+  void maybeCreateInterpolator(const std::string &propertyName);
+
+ private:
+  const InterpolatorFactoriesRecord &factories_;
+  PropertyInterpolatorsRecord interpolators_;
+};
+
+} // namespace reanimated::css