@react-native-ohos/react-native-reanimated 3.18.1-rc.6 → 4.0.0-rc.1

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

@@ -0,0 +1,308 @@
+#include <reanimated/CSS/interpolation/operations/OperationsStyleInterpolator.h>
+
+#include <reanimated/CSS/interpolation/filters/FilterOperation.h>
+#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
+
+namespace reanimated::css {
+
+// OperationsStyleInterpolator implementation
+
+OperationsStyleInterpolator::OperationsStyleInterpolator(
+    const PropertyPath &propertyPath,
+    const std::shared_ptr<StyleOperationInterpolators> &interpolators,
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository,
+    const folly::dynamic &defaultStyleValueDynamic)
+    : PropertyInterpolator(propertyPath, viewStylesRepository),
+      interpolators_(interpolators),
+      defaultStyleValueDynamic_(defaultStyleValueDynamic) {}
+
+folly::dynamic OperationsStyleInterpolator::getStyleValue(const std::shared_ptr<const ShadowNode> &shadowNode) const {
+  return viewStylesRepository_->getStyleProp(shadowNode->getTag(), propertyPath_);
+}
+
+folly::dynamic OperationsStyleInterpolator::getResetStyle(const std::shared_ptr<const ShadowNode> &shadowNode) const {
+  auto styleValue = getStyleValue(shadowNode);
+
+  if (!styleValue.isArray()) {
+    return defaultStyleValueDynamic_;
+  }
+
+  return styleValue;
+}
+
+folly::dynamic OperationsStyleInterpolator::getFirstKeyframeValue() const {
+  const auto &fromOperations = keyframes_.front()->fromOperations;
+  return fromOperations.has_value() ? convertOperationsToDynamic(fromOperations.value()) : defaultStyleValueDynamic_;
+}
+
+folly::dynamic OperationsStyleInterpolator::getLastKeyframeValue() const {
+  const auto &toOperations = keyframes_.back()->toOperations;
+  return toOperations.has_value() ? convertOperationsToDynamic(toOperations.value()) : defaultStyleValueDynamic_;
+}
+
+bool OperationsStyleInterpolator::equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const {
+  const auto propertyOperations = parseStyleOperations(propertyValue);
+
+  if (!reversingAdjustedStartValue_.has_value()) {
+    return !propertyOperations.has_value();
+  } else if (!propertyOperations.has_value()) {
+    return false;
+  }
+
+  const auto &reversingAdjustedOperationsValue = reversingAdjustedStartValue_.value();
+  const auto &propertyOperationsValue = propertyOperations.value();
+
+  if (reversingAdjustedOperationsValue.size() != propertyOperationsValue.size()) {
+    return false;
+  }
+
+  for (size_t i = 0; i < reversingAdjustedOperationsValue.size(); ++i) {
+    if (*reversingAdjustedOperationsValue[i] != *propertyOperationsValue[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+folly::dynamic OperationsStyleInterpolator::interpolate(
+    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const std::shared_ptr<KeyframeProgressProvider> &progressProvider,
+    const double fallbackInterpolateThreshold) const {
+  const auto currentIndex = getIndexOfCurrentKeyframe(progressProvider);
+
+  // Get or create the current keyframe
+  auto keyframe = keyframes_[currentIndex];
+  if (!keyframe->fromOperations.has_value() || !keyframe->toOperations.has_value()) {
+    // If the value is nullopt, we would have to read it from the view style
+    // and build the keyframe again
+    const auto fallbackValue = getFallbackValue(shadowNode);
+    keyframe = createStyleOperationsKeyframe(
+        keyframe->fromOffset,
+        keyframe->toOffset,
+        keyframe->fromOperations.value_or(fallbackValue),
+        keyframe->toOperations.value_or(fallbackValue));
+  }
+
+  double progress = progressProvider->getKeyframeProgress(keyframe->fromOffset, keyframe->toOffset);
+
+  if (keyframe->isDiscrete) {
+    const auto &operations =
+        progress < fallbackInterpolateThreshold ? keyframe->fromOperations.value() : keyframe->toOperations.value();
+    return convertOperationsToDynamic(operations);
+  }
+
+  // Interpolate the current keyframe
+  return interpolateOperations(
+      shadowNode,
+      progress,
+      keyframe->fromOperations.value(),
+      keyframe->toOperations.value(),
+      fallbackInterpolateThreshold);
+}
+
+void OperationsStyleInterpolator::updateKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) {
+  // Step 1: Parse keyframes
+  const auto parsedKeyframes = parseJSIKeyframes(rt, keyframes);
+
+  // Step 2: Convert keyframes to StyleOperations
+  std::vector<std::pair<double, std::optional<StyleOperations>>> operations;
+  operations.reserve(parsedKeyframes.size());
+  for (const auto &[offset, value] : parsedKeyframes) {
+    operations.emplace_back(offset, parseStyleOperations(rt, value));
+  }
+
+  // Step 3: Prepare keyframe interpolation pairs (convert keyframe values in
+  // both keyframes to the same type)
+  // There will be one less keyframe than the number of keyframes in the jsi
+  // array as we create interpolation pairs
+  const auto keyframesCount = operations.size() - 1;
+  keyframes_.clear();
+  keyframes_.reserve(keyframesCount);
+
+  for (size_t i = 0; i < keyframesCount; ++i) {
+    keyframes_.push_back(createStyleOperationsKeyframe(
+        operations[i].first, operations[i + 1].first, operations[i].second, operations[i + 1].second));
+  }
+}
+
+void OperationsStyleInterpolator::updateKeyframesFromStyleChange(
+    const folly::dynamic &oldStyleValue,
+    const folly::dynamic &newStyleValue,
+    const folly::dynamic &lastUpdateValue) {
+  if (oldStyleValue.isNull()) {
+    reversingAdjustedStartValue_ = std::nullopt;
+  } else {
+    reversingAdjustedStartValue_ = parseStyleOperations(oldStyleValue);
+  }
+
+  const auto &prevStyleValue = lastUpdateValue.isNull() ? oldStyleValue : lastUpdateValue;
+
+  keyframes_.clear();
+  keyframes_.reserve(1);
+  keyframes_.emplace_back(createStyleOperationsKeyframe(
+      0,
+      1,
+      parseStyleOperations(prevStyleValue).value_or(StyleOperations{}),
+      parseStyleOperations(newStyleValue).value_or(StyleOperations{})));
+}
+
+std::optional<StyleOperations> OperationsStyleInterpolator::parseStyleOperations(
+    jsi::Runtime &rt,
+    const jsi::Value &values) const {
+  if (values.isUndefined()) {
+    return std::nullopt;
+  }
+
+  const auto operationsArray = values.asObject(rt).asArray(rt);
+  const auto operationsCount = operationsArray.size(rt);
+
+  StyleOperations styleOperations;
+  styleOperations.reserve(operationsCount);
+
+  for (size_t i = 0; i < operationsCount; ++i) {
+    styleOperations.emplace_back(createStyleOperation(rt, operationsArray.getValueAtIndex(rt, i)));
+  }
+
+  return styleOperations;
+}
+
+std::optional<StyleOperations> OperationsStyleInterpolator::parseStyleOperations(const folly::dynamic &values) const {
+  if (values.empty()) {
+    return std::nullopt;
+  }
+
+  const auto &operationsArray = values;
+  const auto operationsCount = operationsArray.size();
+
+  StyleOperations styleOperations;
+  styleOperations.reserve(operationsCount);
+
+  for (size_t i = 0; i < operationsCount; ++i) {
+    styleOperations.emplace_back(createStyleOperation(operationsArray[i]));
+  }
+
+  return styleOperations;
+}
+
+std::shared_ptr<StyleOperationsKeyframe> OperationsStyleInterpolator::createStyleOperationsKeyframe(
+    const double fromOffset,
+    const double toOffset,
+    const std::optional<StyleOperations> &fromOperationsOptional,
+    const std::optional<StyleOperations> &toOperationsOptional) const {
+  bool isDiscrete = false;
+
+  if (fromOperationsOptional.has_value() && toOperationsOptional.has_value()) {
+    // Try to create a compatible interpolation pair
+    const auto interpolationPair =
+        createInterpolationPair(fromOperationsOptional.value(), toOperationsOptional.value());
+
+    if (interpolationPair.has_value()) {
+      const auto [fromOperations, toOperations] = interpolationPair.value();
+      return std::make_shared<StyleOperationsKeyframe>(
+          StyleOperationsKeyframe{fromOffset, toOffset, fromOperations, toOperations, false});
+    }
+
+    // If the operations are not compatible, we need to set the keyframe to discrete
+    isDiscrete = true;
+  }
+
+  return std::make_shared<StyleOperationsKeyframe>(
+      StyleOperationsKeyframe{fromOffset, toOffset, fromOperationsOptional, toOperationsOptional, isDiscrete});
+}
+
+size_t OperationsStyleInterpolator::getIndexOfCurrentKeyframe(
+    const std::shared_ptr<KeyframeProgressProvider> &progressProvider) const {
+  const auto progress = progressProvider->getGlobalProgress();
+
+  const auto it = std::lower_bound(
+      keyframes_.begin(),
+      keyframes_.end(),
+      progress,
+      [](const std::shared_ptr<StyleOperationsKeyframe> &keyframe, double progress) {
+        return keyframe->toOffset < progress;
+      });
+
+  // If we're at the end, return the last valid keyframe index
+  if (it == keyframes_.end()) {
+    return keyframes_.size() - 1;
+  }
+
+  return std::distance(keyframes_.begin(), it);
+}
+
+StyleOperations OperationsStyleInterpolator::getFallbackValue(
+    const std::shared_ptr<const ShadowNode> &shadowNode) const {
+  const auto &styleValue = getStyleValue(shadowNode);
+  return parseStyleOperations(styleValue).value_or(StyleOperations{});
+}
+
+folly::dynamic OperationsStyleInterpolator::interpolateOperations(
+    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const double keyframeProgress,
+    const StyleOperations &fromOperations,
+    const StyleOperations &toOperations,
+    const double fallbackInterpolateThreshold) const {
+  auto result = folly::dynamic::array();
+  result.reserve(fromOperations.size());
+
+  const auto updateContext = createUpdateContext(shadowNode, fallbackInterpolateThreshold);
+
+  for (size_t i = 0; i < fromOperations.size(); ++i) {
+    const auto &fromOperation = fromOperations[i];
+    const auto &toOperation = toOperations[i];
+
+    // fromOperation and toOperation have the same type
+    const auto &interpolator = interpolators_->at(fromOperation->type);
+    const auto interpolationResult =
+        interpolator->interpolate(keyframeProgress, fromOperation, toOperation, updateContext);
+    result.push_back(interpolationResult->toDynamic());
+  }
+
+  return result;
+}
+
+folly::dynamic OperationsStyleInterpolator::convertOperationsToDynamic(const StyleOperations &operations) {
+  auto result = folly::dynamic::array();
+  result.reserve(operations.size());
+
+  for (const auto &operation : operations) {
+    result.push_back(operation->toDynamic());
+  }
+
+  return result;
+}
+
+StyleOperationsInterpolationContext OperationsStyleInterpolator::createUpdateContext(
+    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const double fallbackInterpolateThreshold) const {
+  return StyleOperationsInterpolationContext{
+      shadowNode, viewStylesRepository_, interpolators_, fallbackInterpolateThreshold};
+}
+
+// OperationsStyleInterpolatorBase implementation
+
+template <typename TOperation>
+std::shared_ptr<StyleOperation> OperationsStyleInterpolatorBase<TOperation>::createStyleOperation(
+    jsi::Runtime &rt,
+    const jsi::Value &value) const {
+  return TOperation::fromJSIValue(rt, value);
+}
+
+template <typename TOperation>
+std::shared_ptr<StyleOperation> OperationsStyleInterpolatorBase<TOperation>::createStyleOperation(
+    const folly::dynamic &value) const {
+  return std::static_pointer_cast<StyleOperation>(TOperation::fromDynamic(value));
+}
+
+template <typename TOperation>
+std::shared_ptr<TOperation> OperationsStyleInterpolatorBase<TOperation>::getDefaultOperationOfType(
+    const size_t type) const {
+  return std::static_pointer_cast<TOperation>(interpolators_->at(type)->getDefaultOperation());
+}
+
+// Explicit template instantiation
+template class OperationsStyleInterpolatorBase<FilterOperation>;
+template class OperationsStyleInterpolatorBase<TransformOperation>;
+
+} // namespace reanimated::css

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

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <reanimated/CSS/interpolation/PropertyInterpolator.h>
+#include <reanimated/CSS/interpolation/operations/StyleOperation.h>
+#include <reanimated/CSS/interpolation/operations/StyleOperationInterpolator.h>
+
+#include <memory>
+#include <optional>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace reanimated::css {
+
+struct StyleOperationsKeyframe {
+  const double fromOffset;
+  const double toOffset;
+  // If the value is nullopt, we would have to read it from the view style
+  // (in all other cases, both vectors will have the same number of elements of
+  // corresponding types - elements from the same index will form interpolation
+  // pairs)
+  const std::optional<StyleOperations> fromOperations;
+  const std::optional<StyleOperations> toOperations;
+  // Keyframe is discrete when the fromOperations and toOperations aren't compatible
+  const bool isDiscrete;
+};
+
+class OperationsStyleInterpolator : public PropertyInterpolator {
+ public:
+  OperationsStyleInterpolator(
+      const PropertyPath &propertyPath,
+      const std::shared_ptr<StyleOperationInterpolators> &interpolators,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository,
+      const folly::dynamic &defaultStyleValueDynamic);
+
+  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;
+  bool equalsReversingAdjustedStartValue(const folly::dynamic &propertyValue) const override;
+
+  folly::dynamic interpolate(
+      const std::shared_ptr<const ShadowNode> &shadowNode,
+      const std::shared_ptr<KeyframeProgressProvider> &progressProvider,
+      const double fallbackInterpolateThreshold) 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:
+  const std::shared_ptr<StyleOperationInterpolators> interpolators_;
+
+  virtual std::shared_ptr<StyleOperation> createStyleOperation(jsi::Runtime &rt, const jsi::Value &value) const = 0;
+  virtual std::shared_ptr<StyleOperation> createStyleOperation(const folly::dynamic &value) const = 0;
+  virtual std::optional<std::pair<StyleOperations, StyleOperations>> createInterpolationPair(
+      const StyleOperations &fromOperations,
+      const StyleOperations &toOperations) const = 0;
+
+ private:
+  const folly::dynamic defaultStyleValueDynamic_;
+
+  std::vector<std::shared_ptr<StyleOperationsKeyframe>> keyframes_;
+  std::optional<StyleOperations> reversingAdjustedStartValue_;
+
+  std::optional<StyleOperations> parseStyleOperations(jsi::Runtime &rt, const jsi::Value &values) const;
+  std::optional<StyleOperations> parseStyleOperations(const folly::dynamic &values) const;
+  std::shared_ptr<StyleOperationsKeyframe> createStyleOperationsKeyframe(
+      double fromOffset,
+      double toOffset,
+      const std::optional<StyleOperations> &fromOperationsOptional,
+      const std::optional<StyleOperations> &toOperationsOptional) const;
+  size_t getIndexOfCurrentKeyframe(const std::shared_ptr<KeyframeProgressProvider> &progressProvider) const;
+  StyleOperations getFallbackValue(const std::shared_ptr<const ShadowNode> &shadowNode) const;
+  folly::dynamic interpolateOperations(
+      const std::shared_ptr<const ShadowNode> &shadowNode,
+      double keyframeProgress,
+      const StyleOperations &fromOperations,
+      const StyleOperations &toOperations,
+      double fallbackInterpolateThreshold) const;
+  static folly::dynamic convertOperationsToDynamic(const StyleOperations &operations);
+  StyleOperationsInterpolationContext createUpdateContext(
+      const std::shared_ptr<const ShadowNode> &shadowNode,
+      double fallbackInterpolateThreshold) const;
+};
+
+template <typename TOperation>
+class OperationsStyleInterpolatorBase : public OperationsStyleInterpolator {
+ public:
+  using OperationsStyleInterpolator::OperationsStyleInterpolator;
+
+ protected:
+  std::shared_ptr<StyleOperation> createStyleOperation(jsi::Runtime &rt, const jsi::Value &value) const override;
+  std::shared_ptr<StyleOperation> createStyleOperation(const folly::dynamic &value) const override;
+  std::shared_ptr<TOperation> getDefaultOperationOfType(size_t type) const;
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,19 @@
+#include <reanimated/CSS/interpolation/operations/StyleOperation.h>
+
+namespace reanimated::css {
+
+StyleOperation::StyleOperation(uint8_t type) : type(type) {}
+
+bool StyleOperation::operator==(const StyleOperation &other) const {
+  return type == other.type && areValuesEqual(other);
+}
+
+folly::dynamic StyleOperation::toDynamic() const {
+  return folly::dynamic::object(getOperationName(), valueToDynamic());
+}
+
+bool StyleOperation::shouldResolve() const {
+  return false;
+}
+
+} // namespace reanimated::css

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

@@ -0,0 +1,94 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSValue.h>
+
+#include <folly/dynamic.h>
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace reanimated::css {
+
+using namespace facebook;
+
+//template <typename TOperation>
+//concept ResolvableOp = requires(TOperation operation) {
+//  { operation.value } -> std::convertible_to<typename std::remove_reference_t<decltype(operation.value)>>;
+//  requires Resolvable<std::remove_reference_t<decltype(operation.value)>>;
+//}; // NOLINT(readability/braces)
+
+//template<typename TOperation>
+//struct IsResolvableOpHelper {
+//private:
+//    template<typename T>
+//    static auto test(int) -> decltype(
+//        std::declval<T>().value,
+//        std::declval<typename std::remove_reference_t<decltype(std::declval<T>().value)>>(),
+//        std::declval<Resolvable<typename std::remove_reference_t<decltype(std::declval<T>().value)>>>(),
+//        std::true_type{}
+//    );
+//
+//    template<typename T>
+//    static std::false_type test(...);
+//
+//public:
+//    using type = decltype(test<TOperation>(0));
+//};
+//
+//template<typename TOperation>
+//constexpr bool ResolvableOp = IsResolvableOpHelper<TOperation>::type::value;
+
+
+template <typename T>
+using value_type_t = decltype(std::declval<T>().value);
+
+template <typename T>
+using remove_ref_value_type_t = std::remove_reference_t<value_type_t<T>>;
+
+template <typename T, typename = void>
+struct has_value_member : std::false_type {};
+
+template <typename T>
+struct has_value_member<T, std::void_t<decltype(std::declval<T>().value)>> : std::true_type {};
+
+template <typename T, typename = void>
+struct is_resolvable_op_impl : std::false_type {};
+
+template <typename T>
+struct is_resolvable_op_impl<
+    T,
+    std::enable_if_t<
+        has_value_member<T>::value &&
+        std::is_convertible<value_type_t<T>, remove_ref_value_type_t<T>>::value &&
+        Resolvable<remove_ref_value_type_t<T>>>> : std::true_type {};
+
+
+template <typename TOperation>
+struct is_resolvable_op : reanimated::css::is_resolvable_op_impl<TOperation> {};
+
+template <typename TOperation>
+constexpr bool ResolvableOp = is_resolvable_op<TOperation>::value;
+
+//is_resolvable_op_v
+struct StyleOperation {
+  uint8_t type;
+
+  explicit StyleOperation(uint8_t type);
+  virtual ~StyleOperation() = default;
+
+  bool operator==(const StyleOperation &other) const;
+  folly::dynamic toDynamic() const;
+
+  virtual std::string getOperationName() const = 0;
+  virtual bool shouldResolve() const;
+
+ protected:
+  virtual folly::dynamic valueToDynamic() const = 0;
+  virtual bool areValuesEqual(const StyleOperation &other) const = 0;
+};
+
+using StyleOperations = std::vector<std::shared_ptr<StyleOperation>>;
+
+} // namespace reanimated::css

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

@@ -0,0 +1,18 @@
+#include <reanimated/CSS/interpolation/operations/StyleOperationInterpolator.h>
+
+namespace reanimated::css {
+
+StyleOperationInterpolator::StyleOperationInterpolator(const std::shared_ptr<StyleOperation> &defaultOperation)
+    : defaultOperation_(defaultOperation) {}
+
+std::shared_ptr<StyleOperation> StyleOperationInterpolator::getDefaultOperation() const {
+  return defaultOperation_;
+}
+
+std::shared_ptr<StyleOperation> StyleOperationInterpolator::resolveOperation(
+    const std::shared_ptr<StyleOperation> &operation,
+    const StyleOperationsInterpolationContext &context) const {
+  return operation;
+}
+
+} // namespace reanimated::css

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

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <reanimated/CSS/interpolation/configs.h>
+#include <reanimated/CSS/interpolation/operations/StyleOperation.h>
+#include <reanimated/CSS/misc/ViewStylesRepository.h>
+
+#include <memory>
+#include <unordered_map>
+
+namespace reanimated::css {
+
+class StyleOperationInterpolator {
+ public:
+  using Interpolators = std::unordered_map<size_t, std::shared_ptr<StyleOperationInterpolator>>;
+
+  struct UpdateContext {
+    const std::shared_ptr<const ShadowNode> &node;
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository;
+    const std::shared_ptr<Interpolators> &interpolators;
+    const double fallbackInterpolateThreshold;
+  };
+
+  explicit StyleOperationInterpolator(const std::shared_ptr<StyleOperation> &defaultOperation);
+  virtual ~StyleOperationInterpolator() = default;
+
+  std::shared_ptr<StyleOperation> getDefaultOperation() const;
+  virtual std::unique_ptr<StyleOperation> interpolate(
+      double progress,
+      const std::shared_ptr<StyleOperation> &from,
+      const std::shared_ptr<StyleOperation> &to,
+      const UpdateContext &context) const = 0;
+  virtual std::shared_ptr<StyleOperation> resolveOperation(
+      const std::shared_ptr<StyleOperation> &operation,
+      const UpdateContext &context) const;
+
+ private:
+  const std::shared_ptr<StyleOperation> defaultOperation_;
+};
+
+using StyleOperationInterpolators = StyleOperationInterpolator::Interpolators;
+using StyleOperationsInterpolationContext = StyleOperationInterpolator::UpdateContext;
+
+} // namespace reanimated::css

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <reanimated/CSS/InterpolatorRegistry.h>
+#include <reanimated/CSS/interpolation/groups/RecordPropertiesInterpolator.h>
+
+#include <memory>
+#include <string>
+
+namespace reanimated::css {
+
+// We can just re-use the logic from the RecordPropertiesInterpolator class as
+// interpolating multiple properties from the view style during animation is the
+// same as interpolating record properties
+class AnimationStyleInterpolator : public RecordPropertiesInterpolator {
+ public:
+  explicit AnimationStyleInterpolator(
+      jsi::Runtime &rt,
+      const jsi::Value &keyframes,
+      const std::string &componentName,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
+      : RecordPropertiesInterpolator(getComponentInterpolators(componentName), {}, viewStylesRepository) {
+    updateKeyframes(rt, keyframes);
+  }
+};
+
+} // namespace reanimated::css