@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/InterpolatorFactory.cpp

@@ -0,0 +1,157 @@
+#include <reanimated/CSS/interpolation/InterpolatorFactory.h>
+#include <reanimated/CSS/interpolation/filters/FilterStyleInterpolator.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace reanimated::css {
+
+class RecordInterpolatorFactory : public PropertyInterpolatorFactory {
+ public:
+  explicit RecordInterpolatorFactory(const InterpolatorFactoriesRecord &factories)
+      : PropertyInterpolatorFactory(), factories_(factories) {}
+
+  const CSSValue &getDefaultValue() const override {
+    static EmptyObjectValue emptyObjectValue;
+    return emptyObjectValue;
+  }
+
+  std::shared_ptr<PropertyInterpolator> create(
+      const PropertyPath &propertyPath,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository) const override {
+    return std::make_shared<RecordPropertiesInterpolator>(factories_, propertyPath, viewStylesRepository);
+  }
+
+ private:
+  // Helper private type just for a default value
+  struct EmptyObjectValue : public CSSValue {
+    folly::dynamic toDynamic() const override {
+      return folly::dynamic::object;
+    }
+
+    std::string toString() const override {
+      return "{}";
+    }
+  };
+
+  const InterpolatorFactoriesRecord factories_;
+};
+
+class ArrayLikeInterpolatorFactory : public PropertyInterpolatorFactory {
+ public:
+  const CSSValue &getDefaultValue() const override {
+    static EmptyArrayValue emptyArrayValue;
+    return emptyArrayValue;
+  }
+
+ private:
+  // Helper private type just for a default value
+  struct EmptyArrayValue : public CSSValue {
+    folly::dynamic toDynamic() const override {
+      return folly::dynamic::array;
+    }
+
+    std::string toString() const override {
+      return "[]";
+    }
+  };
+};
+
+class ArrayInterpolatorFactory : public ArrayLikeInterpolatorFactory {
+ public:
+  explicit ArrayInterpolatorFactory(const InterpolatorFactoriesArray &factories)
+      : ArrayLikeInterpolatorFactory(), factories_(factories) {}
+
+  std::shared_ptr<PropertyInterpolator> create(
+      const PropertyPath &propertyPath,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository) const override {
+    return std::make_shared<ArrayPropertiesInterpolator>(factories_, propertyPath, viewStylesRepository);
+  }
+
+ private:
+  const InterpolatorFactoriesArray factories_;
+};
+
+class FiltersInterpolatorFactory : public ArrayLikeInterpolatorFactory {
+ public:
+  explicit FiltersInterpolatorFactory(const std::shared_ptr<StyleOperationInterpolators> &interpolators)
+      : ArrayLikeInterpolatorFactory(), interpolators_(interpolators) {}
+
+  std::shared_ptr<PropertyInterpolator> create(
+      const PropertyPath &propertyPath,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository) const override {
+    return std::make_shared<FilterStyleInterpolator>(propertyPath, interpolators_, viewStylesRepository);
+  }
+
+ private:
+  const std::shared_ptr<StyleOperationInterpolators> interpolators_;
+};
+
+class TransformsInterpolatorFactory : public PropertyInterpolatorFactory {
+ public:
+  explicit TransformsInterpolatorFactory(const std::shared_ptr<StyleOperationInterpolators> &interpolators)
+      : PropertyInterpolatorFactory(), interpolators_(interpolators) {}
+
+  const CSSValue &getDefaultValue() const override {
+    static EmptyTransformsValue emptyTransformsValue;
+    return emptyTransformsValue;
+  }
+
+  std::shared_ptr<PropertyInterpolator> create(
+      const PropertyPath &propertyPath,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository) const override {
+    return std::make_shared<TransformsStyleInterpolator>(propertyPath, interpolators_, viewStylesRepository);
+  }
+
+ private:
+  static TransformMatrix2D &getIdentityMatrix() {
+    static TransformMatrix2D identityMatrix = TransformMatrix2D();
+    return identityMatrix;
+  }
+
+  // Helper private type just for a default value
+  struct EmptyTransformsValue : public CSSValue {
+    folly::dynamic toDynamic() const override {
+      return getIdentityMatrix().toDynamic();
+    }
+
+    std::string toString() const override {
+      return getIdentityMatrix().toString();
+    }
+  };
+
+  const std::shared_ptr<StyleOperationInterpolators> interpolators_;
+};
+
+// Non-template function implementations
+std::shared_ptr<PropertyInterpolatorFactory> record(const InterpolatorFactoriesRecord &factories) {
+  return std::make_shared<RecordInterpolatorFactory>(factories);
+}
+
+std::shared_ptr<PropertyInterpolatorFactory> array(const InterpolatorFactoriesArray &factories) {
+  return std::make_shared<ArrayInterpolatorFactory>(factories);
+}
+
+std::shared_ptr<PropertyInterpolatorFactory> transforms(
+    const std::unordered_map<std::string, std::shared_ptr<StyleOperationInterpolator>> &interpolators) {
+  StyleOperationInterpolators result;
+  result.reserve(interpolators.size());
+  for (const auto &[property, interpolator] : interpolators) {
+    result.emplace(static_cast<size_t>(getTransformOperationType(property)), interpolator);
+  }
+  return std::make_shared<TransformsInterpolatorFactory>(
+      std::make_shared<StyleOperationInterpolators>(std::move(result)));
+}
+
+std::shared_ptr<PropertyInterpolatorFactory> filters(
+    const std::unordered_map<std::string, std::shared_ptr<StyleOperationInterpolator>> &interpolators) {
+  StyleOperationInterpolators result;
+  result.reserve(interpolators.size());
+  for (const auto &[property, interpolator] : interpolators) {
+    result.emplace(static_cast<size_t>(getFilterOperationType(property)), interpolator);
+  }
+  return std::make_shared<FiltersInterpolatorFactory>(std::make_shared<StyleOperationInterpolators>(std::move(result)));
+}
+
+} // namespace reanimated::css

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

@@ -0,0 +1,189 @@
+#pragma once
+
+#include <reanimated/CSS/interpolation/PropertyInterpolator.h>
+#include <reanimated/CSS/interpolation/configs.h>
+#include <reanimated/CSS/interpolation/filters/FilterOperation.h>
+#include <reanimated/CSS/interpolation/filters/FilterOperationInterpolator.h>
+#include <reanimated/CSS/interpolation/groups/ArrayPropertiesInterpolator.h>
+#include <reanimated/CSS/interpolation/groups/RecordPropertiesInterpolator.h>
+#include <reanimated/CSS/interpolation/operations/StyleOperationInterpolator.h>
+#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
+#include <reanimated/CSS/interpolation/transforms/TransformOperationInterpolator.h>
+#include <reanimated/CSS/interpolation/transforms/TransformsStyleInterpolator.h>
+#include <reanimated/CSS/interpolation/values/ResolvableValueInterpolator.h>
+#include <reanimated/CSS/interpolation/values/SimpleValueInterpolator.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+namespace reanimated::css {
+
+// Template class implementations
+template <typename... AllowedTypes>
+class SimpleValueInterpolatorFactory : public PropertyInterpolatorFactory {
+ public:
+  template <typename TValue>
+  explicit SimpleValueInterpolatorFactory(const TValue &defaultValue)
+      : PropertyInterpolatorFactory(), defaultValue_(defaultValue) {}
+
+  bool isDiscreteProperty() const override {
+    // The property is considered discrete if all of the allowed types are
+    // discrete
+    return (Discrete<AllowedTypes> && ...);
+  }
+
+  const CSSValue &getDefaultValue() const override {
+    return defaultValue_;
+  }
+
+  std::shared_ptr<PropertyInterpolator> create(
+      const PropertyPath &propertyPath,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository) const override {
+    return std::make_shared<SimpleValueInterpolator<AllowedTypes...>>(
+        propertyPath, defaultValue_, viewStylesRepository);
+  }
+
+ private:
+  const CSSValueVariant<AllowedTypes...> defaultValue_;
+};
+
+template <typename... AllowedTypes>
+class ResolvableValueInterpolatorFactory : public PropertyInterpolatorFactory {
+ public:
+  template <typename TValue>
+  explicit ResolvableValueInterpolatorFactory(const TValue &defaultValue, ResolvableValueInterpolatorConfig config)
+      : PropertyInterpolatorFactory(), defaultValue_(defaultValue), config_(std::move(config)) {}
+
+  const CSSValue &getDefaultValue() const override {
+    return defaultValue_;
+  }
+
+  std::shared_ptr<PropertyInterpolator> create(
+      const PropertyPath &propertyPath,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository) const override {
+    return std::make_shared<ResolvableValueInterpolator<AllowedTypes...>>(
+        propertyPath, defaultValue_, viewStylesRepository, config_);
+  }
+
+ private:
+  const CSSValueVariant<AllowedTypes...> defaultValue_;
+  ResolvableValueInterpolatorConfig config_;
+};
+
+/**
+ * Helper function to create a concrete CSSValue from defaultValue
+ */
+template <typename... AllowedTypes>
+CSSValueVariant<AllowedTypes...> createCSSValue(const auto &defaultValue) {
+  using ValueType = decltype(defaultValue);
+  CSSValueVariant<AllowedTypes...> result;
+
+  auto tryOne = [&]<typename TCSSValue>() -> bool {
+    if constexpr (std::is_constructible_v<TCSSValue, ValueType>) {
+      if constexpr (ValueConstructibleCSSValue<TCSSValue, ValueType>) {
+        // For construction from a non-jsi::Value, we perform a runtime
+        // canConstruct check only if the type has a canConstruct method.
+        // (this is needed e.g. when different CSS value types can be
+        // constructed from the same value type, like CSSLength and CSSKeyword)
+        if (!TCSSValue::canConstruct(defaultValue)) {
+          return false;
+        }
+      }
+      result = CSSValueVariant<AllowedTypes...>(std::variant<AllowedTypes...>(TCSSValue(defaultValue)));
+      return true;
+    }
+    return false;
+  };
+
+  // Try constructing with each allowed type until one succeeds
+  if (!(tryOne.template operator()<AllowedTypes>() || ...)) {
+    throw std::runtime_error("[Reanimated] No compatible type found for construction from defaultValue");
+  }
+
+  return result;
+}
+
+/**
+ * Value interpolator factories
+ */
+template <typename... AllowedTypes>
+auto value(const auto &defaultValue) -> std::enable_if_t<
+    (std::is_constructible_v<AllowedTypes, decltype(defaultValue)> || ...),
+    std::shared_ptr<PropertyInterpolatorFactory>> {
+  // Create a concrete CSSValue from the defaultValue
+  auto cssValue = createCSSValue<AllowedTypes...>(defaultValue);
+  return std::make_shared<SimpleValueInterpolatorFactory<AllowedTypes...>>(std::move(cssValue));
+}
+
+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>> {
+  // Create a concrete CSSValue from the defaultValue
+  auto cssValue = createCSSValue<AllowedTypes...>(defaultValue);
+  return std::make_shared<ResolvableValueInterpolatorFactory<AllowedTypes...>>(std::move(cssValue), std::move(config));
+}
+
+/**
+ * Transform operation interpolator factories
+ */
+template <typename TOperation>
+auto transformOp(const auto &defaultValue) -> std::enable_if_t<
+    std::is_base_of_v<TransformOperation, TOperation> && std::is_constructible_v<TOperation, decltype(defaultValue)>,
+    std::shared_ptr<StyleOperationInterpolator>> {
+  return std::make_shared<TransformOperationInterpolator<TOperation>>(std::make_shared<TOperation>(defaultValue));
+}
+
+template <typename TOperation>
+auto transformOp(const auto &defaultValue, ResolvableValueInterpolatorConfig config) -> std::enable_if_t<
+    std::is_base_of_v<TransformOperation, TOperation> && std::is_constructible_v<TOperation, decltype(defaultValue)> &&
+        ResolvableOp<TOperation>,
+    std::shared_ptr<StyleOperationInterpolator>> {
+  return std::make_shared<TransformOperationInterpolator<TOperation>>(
+      std::make_shared<TOperation>(defaultValue), std::move(config));
+}
+
+/**
+ * Filter operation interpolator factories
+ */
+template <typename TOperation>
+auto filterOp(const auto &defaultValue) -> std::enable_if_t<
+    std::is_base_of_v<FilterOperation, TOperation> && std::is_constructible_v<TOperation, decltype(defaultValue)>,
+    std::shared_ptr<StyleOperationInterpolator>> {
+  return std::make_shared<FilterOperationInterpolator<TOperation>>(std::make_shared<TOperation>(defaultValue));
+}
+
+template <typename TOperation>
+auto filterOp(const auto &defaultValue, ResolvableValueInterpolatorConfig config) -> std::enable_if_t<
+    std::is_base_of_v<FilterOperation, TOperation> && std::is_constructible_v<TOperation, decltype(defaultValue)> &&
+        ResolvableOp<TOperation>,
+    std::shared_ptr<StyleOperationInterpolator>> {
+  return std::make_shared<FilterOperationInterpolator<TOperation>>(
+      std::make_shared<TOperation>(defaultValue), std::move(config));
+}
+
+/**
+ * Record property interpolator factory
+ */
+std::shared_ptr<PropertyInterpolatorFactory> record(const InterpolatorFactoriesRecord &factories);
+
+/**
+ * Array property interpolator factory
+ */
+std::shared_ptr<PropertyInterpolatorFactory> array(const InterpolatorFactoriesArray &factories);
+
+/**
+ * Transform interpolators
+ */
+std::shared_ptr<PropertyInterpolatorFactory> transforms(
+    const std::unordered_map<std::string, std::shared_ptr<StyleOperationInterpolator>> &interpolators);
+
+/**
+* Filter interpolators
+*/
+std::shared_ptr<PropertyInterpolatorFactory> filters(
+    const std::unordered_map<std::string, std::shared_ptr<StyleOperationInterpolator>> &interpolators);
+
+} // namespace reanimated::css

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

@@ -0,0 +1,76 @@
+#include <reanimated/CSS/interpolation/PropertyInterpolator.h>
+
+#include <worklets/Tools/JSISerializer.h>
+
+#include <memory>
+#include <utility>
+
+namespace reanimated::css {
+
+PropertyInterpolator::PropertyInterpolator(
+    PropertyPath propertyPath,
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
+    : propertyPath_(std::move(propertyPath)), viewStylesRepository_(viewStylesRepository) {}
+
+bool PropertyInterpolatorFactory::isDiscreteProperty() const {
+  return false;
+}
+
+std::string PropertyInterpolator::getPropertyPathString() const {
+  if (propertyPath_.empty()) {
+    return "";
+  }
+
+  std::string result = propertyPath_[0];
+  for (size_t i = 1; i < propertyPath_.size(); ++i) {
+    result += "." + propertyPath_[i];
+  }
+  return result;
+}
+
+std::vector<std::pair<double, jsi::Value>> PropertyInterpolator::parseJSIKeyframes(
+    jsi::Runtime &rt,
+    const jsi::Value &keyframes) const {
+  if (!keyframes.isObject() || !keyframes.asObject(rt).isArray(rt)) {
+    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));
+  }
+
+  const auto keyframeArray = keyframes.asObject(rt).asArray(rt);
+  const auto keyframesCount = keyframeArray.size(rt);
+
+  const auto getKeyframeAtIndexOffset = [&](size_t index) -> double {
+    return keyframeArray.getValueAtIndex(rt, index).asObject(rt).getProperty(rt, "offset").asNumber();
+  };
+
+  const bool hasOffset0 = getKeyframeAtIndexOffset(0) == 0;
+  const bool hasOffset1 = getKeyframeAtIndexOffset(keyframesCount - 1) == 1;
+
+  std::vector<std::pair<double, jsi::Value>> result;
+  result.reserve(keyframesCount + (hasOffset0 ? 0 : 1) + (hasOffset1 ? 0 : 1));
+
+  // Insert the keyframe without value at offset 0 if it is not present
+  if (!hasOffset0) {
+    result.emplace_back(0.0, jsi::Value::undefined());
+  }
+
+  // Insert all provided keyframes
+  for (size_t i = 0; i < keyframesCount; ++i) {
+    jsi::Object keyframeObject = keyframeArray.getValueAtIndex(rt, i).asObject(rt);
+    double offset = keyframeObject.getProperty(rt, "offset").asNumber();
+    jsi::Value value = keyframeObject.getProperty(rt, "value");
+
+    result.emplace_back(offset, std::move(value));
+  }
+
+  // Insert the keyframe without value at offset 1 if it is not present
+  if (!hasOffset1) {
+    result.emplace_back(1.0, jsi::Value::undefined());
+  }
+
+  return result;
+}
+
+} // namespace reanimated::css

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

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <reanimated/CSS/common/definitions.h>
+#include <reanimated/CSS/common/values/CSSValue.h>
+#include <reanimated/CSS/misc/ViewStylesRepository.h>
+#include <reanimated/CSS/progress/KeyframeProgressProvider.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace reanimated::css {
+
+class PropertyInterpolator {
+ public:
+  explicit PropertyInterpolator(
+      PropertyPath propertyPath,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
+
+  virtual folly::dynamic getStyleValue(const std::shared_ptr<const ShadowNode> &shadowNode) const = 0;
+  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 folly::dynamic interpolate(
+      const std::shared_ptr<const ShadowNode> &shadowNode,
+      const std::shared_ptr<KeyframeProgressProvider> &progressProvider,
+      double fallbackInterpolateThreshold) const = 0;
+
+ protected:
+  const PropertyPath propertyPath_;
+  const std::shared_ptr<ViewStylesRepository> viewStylesRepository_;
+
+  std::string getPropertyPathString() const;
+  std::vector<std::pair<double, jsi::Value>> parseJSIKeyframes(jsi::Runtime &rt, const jsi::Value &keyframes) const;
+};
+
+class PropertyInterpolatorFactory {
+ public:
+  PropertyInterpolatorFactory() = default;
+  virtual ~PropertyInterpolatorFactory() = default;
+
+  virtual bool isDiscreteProperty() const;
+  virtual const CSSValue &getDefaultValue() const = 0;
+
+  virtual std::shared_ptr<PropertyInterpolator> create(
+      const PropertyPath &propertyPath,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository) const = 0;
+};
+
+using PropertyInterpolatorsRecord = std::unordered_map<std::string, std::shared_ptr<PropertyInterpolator>>;
+using InterpolatorFactoriesRecord = std::unordered_map<std::string, std::shared_ptr<PropertyInterpolatorFactory>>;
+
+using PropertyInterpolatorsArray = std::vector<std::shared_ptr<PropertyInterpolator>>;
+using InterpolatorFactoriesArray = std::vector<std::shared_ptr<PropertyInterpolatorFactory>>;
+
+} // namespace reanimated::css

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

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSLength.h>
+
+#include <string>
+#include <utility>
+
+namespace reanimated::css {
+
+struct ResolvableValueInterpolatorConfig {
+  RelativeTo relativeTo;
+  std::string relativeProperty;
+
+  ResolvableValueInterpolatorConfig(RelativeTo relativeTo, std::string relativeProperty)
+      : relativeTo(relativeTo), relativeProperty(std::move(relativeProperty)) {}
+
+  ResolvableValueInterpolatorConfig() = default;
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,136 @@
+#include <reanimated/CSS/interpolation/filters/FilterOperation.h>
+
+#include <reanimated/CSS/common/values/CSSAngle.h>
+#include <reanimated/CSS/common/values/CSSNumber.h>
+#include <reanimated/CSS/common/values/complex/CSSDropShadow.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>
+
+#include <utility>
+
+namespace reanimated::css {
+
+FilterOperation::FilterOperation(FilterOp type) : StyleOperation(static_cast<uint8_t>(type)) {}
+
+std::string FilterOperation::getOperationName() const {
+  return getFilterOperationName(static_cast<FilterOp>(type));
+}
+
+std::shared_ptr<FilterOperation> FilterOperation::fromJSIValue(jsi::Runtime &rt, const jsi::Value &value) {
+  if (!value.isObject()) {
+    throw std::invalid_argument("[Reanimated] FilterOperation must be an object.");
+  }
+
+  jsi::Object obj = value.asObject(rt);
+  auto propertyNames = obj.getPropertyNames(rt);
+
+  if (propertyNames.size(rt) != 1) {
+    throw std::invalid_argument("[Reanimated] FilterOperation must have exactly one property.");
+  }
+
+  const auto propertyName = propertyNames.getValueAtIndex(rt, 0).asString(rt).utf8(rt);
+  const auto propertyValue = obj.getProperty(rt, jsi::PropNameID::forUtf8(rt, propertyName));
+  FilterOp operationType = getFilterOperationType(propertyName);
+
+  switch (operationType) {
+    case FilterOp::Blur:
+      return std::make_shared<BlurOperation>(propertyValue.asNumber());
+    case FilterOp::Brightness:
+      return std::make_shared<BrightnessOperation>(propertyValue.asNumber());
+    case FilterOp::Contrast:
+      return std::make_shared<ContrastOperation>(propertyValue.asNumber());
+    case FilterOp::DropShadow:
+      return std::make_shared<DropShadowOperation>(CSSDropShadow(rt, propertyValue));
+    case FilterOp::Grayscale:
+      return std::make_shared<GrayscaleOperation>(propertyValue.asNumber());
+    case FilterOp::HueRotate:
+      return std::make_shared<HueRotateOperation>(propertyValue.asNumber());
+    case FilterOp::Invert:
+      return std::make_shared<InvertOperation>(propertyValue.asNumber());
+    case FilterOp::Opacity:
+      return std::make_shared<OpacityOperation>(propertyValue.asNumber());
+    case FilterOp::Saturate:
+      return std::make_shared<SaturateOperation>(propertyValue.asNumber());
+    case FilterOp::Sepia:
+      return std::make_shared<SepiaOperation>(propertyValue.asNumber());
+    default:
+      throw std::invalid_argument("[Reanimated] Unknown filter operation: " + propertyName);
+  }
+}
+
+std::shared_ptr<FilterOperation> FilterOperation::fromDynamic(const folly::dynamic &value) {
+  if (!value.isObject()) {
+    throw std::invalid_argument("[Reanimated] FilterOperation must be an object.");
+  }
+
+  auto &obj = value;
+  if (obj.size() != 1) {
+    throw std::invalid_argument("[Reanimated] FilterOperation must have exactly one property.");
+  }
+
+  auto propertyName = obj.items().begin()->first.getString();
+  auto propertyValue = obj.items().begin()->second;
+  FilterOp operationType = getFilterOperationType(propertyName);
+
+  switch (operationType) {
+    case FilterOp::Blur:
+      return std::make_shared<BlurOperation>(propertyValue.getDouble());
+    case FilterOp::Brightness:
+      return std::make_shared<BrightnessOperation>(propertyValue.getDouble());
+    case FilterOp::Contrast:
+      return std::make_shared<ContrastOperation>(propertyValue.getDouble());
+    case FilterOp::DropShadow:
+      return std::make_shared<DropShadowOperation>(CSSDropShadow(propertyValue));
+    case FilterOp::Grayscale:
+      return std::make_shared<GrayscaleOperation>(propertyValue.getDouble());
+    case FilterOp::HueRotate:
+      return std::make_shared<HueRotateOperation>(propertyValue.getDouble());
+    case FilterOp::Invert:
+      return std::make_shared<InvertOperation>(propertyValue.getDouble());
+    case FilterOp::Opacity:
+      return std::make_shared<OpacityOperation>(propertyValue.getDouble());
+    case FilterOp::Saturate:
+      return std::make_shared<SaturateOperation>(propertyValue.getDouble());
+    case FilterOp::Sepia:
+      return std::make_shared<SepiaOperation>(propertyValue.getDouble());
+    default:
+      throw std::invalid_argument("[Reanimated] Unknown filter operation: " + propertyName);
+  }
+}
+
+// FilterOperationBase implementation
+template <FilterOp TOperation, typename  TValue>
+FilterOperationBase<TOperation, TValue>::FilterOperationBase(TValue value)
+    : FilterOperation(TOperation), value(std::move(value)) {}
+
+template <FilterOp TOperation, typename  TValue>
+folly::dynamic FilterOperationBase<TOperation, TValue>::valueToDynamic() const {
+  return value.toDynamic();
+}
+
+template <FilterOp TOperation, typename  TValue>
+bool FilterOperationBase<TOperation, TValue>::areValuesEqual(const StyleOperation &other) const {
+  return value == static_cast<const FilterOperationBase<TOperation, TValue> &>(other).value;
+}
+
+template struct FilterOperationBase<FilterOp::Blur, CSSDouble>;
+template struct FilterOperationBase<FilterOp::Brightness, CSSDouble>;
+template struct FilterOperationBase<FilterOp::Contrast, CSSDouble>;
+template struct FilterOperationBase<FilterOp::DropShadow, CSSDropShadow>;
+template struct FilterOperationBase<FilterOp::Grayscale, CSSDouble>;
+template struct FilterOperationBase<FilterOp::HueRotate, CSSDouble>;
+template struct FilterOperationBase<FilterOp::Invert, CSSDouble>;
+template struct FilterOperationBase<FilterOp::Opacity, CSSDouble>;
+template struct FilterOperationBase<FilterOp::Saturate, CSSDouble>;
+template struct FilterOperationBase<FilterOp::Sepia, CSSDouble>;
+
+} // namespace reanimated::css

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

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <reanimated/CSS/common/filters/FilterOp.h>
+#include <reanimated/CSS/common/values/CSSValue.h>
+#include <reanimated/CSS/interpolation/operations/StyleOperation.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace reanimated::css {
+
+using namespace facebook;
+
+// Base struct for FilterOperations
+struct FilterOperation : public StyleOperation {
+  explicit FilterOperation(FilterOp type);
+
+  std::string getOperationName() const override;
+
+  static std::shared_ptr<FilterOperation> fromJSIValue(jsi::Runtime &rt, const jsi::Value &value);
+  static std::shared_ptr<FilterOperation> fromDynamic(const folly::dynamic &value);
+};
+
+using FilterOperations = std::vector<std::shared_ptr<FilterOperation>>;
+
+// Base implementation for filter operations
+template <FilterOp TOperation, typename  TValue>
+struct FilterOperationBase : public FilterOperation {
+  const TValue value;
+
+  explicit FilterOperationBase(TValue value);
+
+ protected:
+  folly::dynamic valueToDynamic() const override;
+  bool areValuesEqual(const StyleOperation &other) const override;
+};
+
+} // namespace reanimated::css