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

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

@@ -1,66 +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
+#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

@@ -1,20 +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
+#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

@@ -1,136 +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
+#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

@@ -1,40 +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
+#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

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

@@ -1,38 +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
+#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