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

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

@@ -1,22 +1,22 @@
-#pragma once
-
-#include <reanimated/CSS/easing/cubicBezier.h>
-#include <reanimated/CSS/easing/linear.h>
-#include <reanimated/CSS/easing/steps.h>
-
-#include <jsi/jsi.h>
-#include <string>
-#include <unordered_map>
-
-namespace reanimated::css {
-
-using namespace facebook;
-
-extern const std::unordered_map<std::string, EasingFunction> PREDEFINED_EASING_MAP;
-
-EasingFunction getPredefinedEasingFunction(const std::string &name);
-EasingFunction createParametrizedEasingFunction(jsi::Runtime &rt, const jsi::Object &easingConfig);
-
-EasingFunction createEasingFunction(jsi::Runtime &rt, const jsi::Value &easingConfig);
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/easing/cubicBezier.h>
+#include <reanimated/CSS/easing/linear.h>
+#include <reanimated/CSS/easing/steps.h>
+
+#include <jsi/jsi.h>
+#include <string>
+#include <unordered_map>
+
+namespace reanimated::css {
+
+using namespace facebook;
+
+extern const std::unordered_map<std::string, EasingFunction> PREDEFINED_EASING_MAP;
+
+EasingFunction getPredefinedEasingFunction(const std::string &name);
+EasingFunction createParametrizedEasingFunction(jsi::Runtime &rt, const jsi::Object &easingConfig);
+
+EasingFunction createEasingFunction(jsi::Runtime &rt, const jsi::Value &easingConfig);
+
+} // namespace reanimated::css

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

@@ -1,66 +1,66 @@
-#include <reanimated/CSS/easing/cubicBezier.h>
-
-namespace reanimated::css {
-
-double sampleCurveX(const double t, const double x1, const double x2) {
-  return 3 * (1 - t) * (1 - t) * t * x1 + 3 * (1 - t) * t * t * x2 + t * t * t;
-}
-
-double sampleCurveY(const double t, const double y1, const double y2) {
-  return 3 * (1 - t) * (1 - t) * t * y1 + 3 * (1 - t) * t * t * y2 + t * t * t;
-}
-
-double sampleCurveDerivativeX(const double t, const double x1, const double x2) {
-  return -6 * (1 - t) * t * x1 + 3 * (1 - t) * (1 - t) * x1 + 6 * (1 - t) * t * x2 - 6 * t * t * x2 + 3 * t * t;
-}
-
-double solveCurveX(const double x, const double x1, const double x2, const double epsilon) {
-  double t0 = 0.0, t1 = 1.0, t2 = x, xValue, dX;
-  int iterations = 0;
-
-  while (iterations < 8) {
-    xValue = sampleCurveX(t2, x1, x2) - x;
-    if (std::abs(xValue) < epsilon) {
-      return t2;
-    }
-    dX = sampleCurveDerivativeX(t2, x1, x2);
-    if (std::abs(dX) < epsilon) {
-      break;
-    }
-    t2 = t2 - xValue / dX;
-    iterations++;
-  }
-
-  // Fallback: Use binary search
-  while (t0 < t1) {
-    t2 = (t0 + t1) / 2.0;
-    xValue = sampleCurveX(t2, x1, x2);
-    if (std::abs(xValue - x) < epsilon) {
-      return t2;
-    }
-    if (x > xValue) {
-      t0 = t2;
-    } else {
-      t1 = t2;
-    }
-  }
-
-  return t2;
-}
-
-EasingFunction cubicBezier(const double x1, const double y1, const double x2, const double y2) {
-  return [=](double x) {
-    double t = solveCurveX(x, x1, x2);
-    return sampleCurveY(t, y1, y2);
-  };
-}
-
-EasingFunction cubicBezier(jsi::Runtime &rt, const jsi::Object &easingConfig) {
-  const auto x1 = easingConfig.getProperty(rt, "x1").asNumber();
-  const auto y1 = easingConfig.getProperty(rt, "y1").asNumber();
-  const auto x2 = easingConfig.getProperty(rt, "x2").asNumber();
-  const auto y2 = easingConfig.getProperty(rt, "y2").asNumber();
-  return cubicBezier(x1, y1, x2, y2);
-}
-
-} // namespace reanimated::css
+#include <reanimated/CSS/easing/cubicBezier.h>
+
+namespace reanimated::css {
+
+double sampleCurveX(const double t, const double x1, const double x2) {
+  return 3 * (1 - t) * (1 - t) * t * x1 + 3 * (1 - t) * t * t * x2 + t * t * t;
+}
+
+double sampleCurveY(const double t, const double y1, const double y2) {
+  return 3 * (1 - t) * (1 - t) * t * y1 + 3 * (1 - t) * t * t * y2 + t * t * t;
+}
+
+double sampleCurveDerivativeX(const double t, const double x1, const double x2) {
+  return -6 * (1 - t) * t * x1 + 3 * (1 - t) * (1 - t) * x1 + 6 * (1 - t) * t * x2 - 6 * t * t * x2 + 3 * t * t;
+}
+
+double solveCurveX(const double x, const double x1, const double x2, const double epsilon) {
+  double t0 = 0.0, t1 = 1.0, t2 = x, xValue, dX;
+  int iterations = 0;
+
+  while (iterations < 8) {
+    xValue = sampleCurveX(t2, x1, x2) - x;
+    if (std::abs(xValue) < epsilon) {
+      return t2;
+    }
+    dX = sampleCurveDerivativeX(t2, x1, x2);
+    if (std::abs(dX) < epsilon) {
+      break;
+    }
+    t2 = t2 - xValue / dX;
+    iterations++;
+  }
+
+  // Fallback: Use binary search
+  while (t0 < t1) {
+    t2 = (t0 + t1) / 2.0;
+    xValue = sampleCurveX(t2, x1, x2);
+    if (std::abs(xValue - x) < epsilon) {
+      return t2;
+    }
+    if (x > xValue) {
+      t0 = t2;
+    } else {
+      t1 = t2;
+    }
+  }
+
+  return t2;
+}
+
+EasingFunction cubicBezier(const double x1, const double y1, const double x2, const double y2) {
+  return [=](double x) {
+    double t = solveCurveX(x, x1, x2);
+    return sampleCurveY(t, y1, y2);
+  };
+}
+
+EasingFunction cubicBezier(jsi::Runtime &rt, const jsi::Object &easingConfig) {
+  const auto x1 = easingConfig.getProperty(rt, "x1").asNumber();
+  const auto y1 = easingConfig.getProperty(rt, "y1").asNumber();
+  const auto x2 = easingConfig.getProperty(rt, "x2").asNumber();
+  const auto y2 = easingConfig.getProperty(rt, "y2").asNumber();
+  return cubicBezier(x1, y1, x2, y2);
+}
+
+} // namespace reanimated::css

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

@@ -1,15 +1,15 @@
-#pragma once
-
-#include <reanimated/CSS/common/definitions.h>
-
-namespace reanimated::css {
-
-double sampleCurveX(double t, double x1, double x2);
-double sampleCurveY(double t, double y1, double y2);
-double sampleCurveDerivativeX(double t, double x1, double x2);
-double solveCurveX(double x, double x1, double x2, double epsilon = 1e-6);
-
-EasingFunction cubicBezier(double x1, double y1, double x2, double y2);
-EasingFunction cubicBezier(jsi::Runtime &rt, const jsi::Object &easingConfig);
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/definitions.h>
+
+namespace reanimated::css {
+
+double sampleCurveX(double t, double x1, double x2);
+double sampleCurveY(double t, double y1, double y2);
+double sampleCurveDerivativeX(double t, double x1, double x2);
+double solveCurveX(double x, double x1, double x2, double epsilon = 1e-6);
+
+EasingFunction cubicBezier(double x1, double y1, double x2, double y2);
+EasingFunction cubicBezier(jsi::Runtime &rt, const jsi::Object &easingConfig);
+
+} // namespace reanimated::css

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

@@ -1,28 +1,28 @@
-#include <reanimated/CSS/easing/linear.h>
-
-#include <vector>
-
-namespace reanimated::css {
-
-double
-interpolateValue(double x, size_t leftIdx, const std::vector<double> &pointsX, const std::vector<double> &pointsY) {
-  if (leftIdx == pointsX.size() - 1) {
-    // We are exactly on the last point of the curve, we just return its y
-    // coordinate
-    return pointsY[leftIdx];
-  }
-  const auto rightIdx = leftIdx + 1;
-  // Calculate the line equation for the line between leftIdx and rightIdx
-  // points
-  const auto a = (pointsY[rightIdx] - pointsY[leftIdx]) / (pointsX[rightIdx] - pointsX[leftIdx]);
-  return pointsY[leftIdx] + a * (x - pointsX[leftIdx]);
-}
-
-EasingFunction linear(const std::vector<double> &pointsX, const std::vector<double> &pointsY) {
-  return [=](double x) {
-    size_t leftIdx = firstSmallerOrEqual(x, pointsX);
-    return interpolateValue(x, leftIdx, pointsX, pointsY);
-  };
-}
-
-} // namespace reanimated::css
+#include <reanimated/CSS/easing/linear.h>
+
+#include <vector>
+
+namespace reanimated::css {
+
+double
+interpolateValue(double x, size_t leftIdx, const std::vector<double> &pointsX, const std::vector<double> &pointsY) {
+  if (leftIdx == pointsX.size() - 1) {
+    // We are exactly on the last point of the curve, we just return its y
+    // coordinate
+    return pointsY[leftIdx];
+  }
+  const auto rightIdx = leftIdx + 1;
+  // Calculate the line equation for the line between leftIdx and rightIdx
+  // points
+  const auto a = (pointsY[rightIdx] - pointsY[leftIdx]) / (pointsX[rightIdx] - pointsX[leftIdx]);
+  return pointsY[leftIdx] + a * (x - pointsX[leftIdx]);
+}
+
+EasingFunction linear(const std::vector<double> &pointsX, const std::vector<double> &pointsY) {
+  return [=](double x) {
+    size_t leftIdx = firstSmallerOrEqual(x, pointsX);
+    return interpolateValue(x, leftIdx, pointsX, pointsY);
+  };
+}
+
+} // namespace reanimated::css

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

@@ -1,15 +1,15 @@
-#pragma once
-
-#include <reanimated/CSS/common/definitions.h>
-#include <reanimated/CSS/utils/algorithms.h>
-
-#include <vector>
-
-namespace reanimated::css {
-
-double
-interpolateValue(double x, std::size_t leftIdx, const std::vector<double> &arrX, const std::vector<double> &arrY);
-
-EasingFunction linear(const std::vector<double> &pointsX, const std::vector<double> &pointsY);
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/definitions.h>
+#include <reanimated/CSS/utils/algorithms.h>
+
+#include <vector>
+
+namespace reanimated::css {
+
+double
+interpolateValue(double x, std::size_t leftIdx, const std::vector<double> &arrX, const std::vector<double> &arrY);
+
+EasingFunction linear(const std::vector<double> &pointsX, const std::vector<double> &pointsY);
+
+} // namespace reanimated::css

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

@@ -1,13 +1,13 @@
-#include <reanimated/CSS/easing/steps.h>
-
-#include <vector>
-
-namespace reanimated::css {
-EasingFunction steps(const std::vector<double> &pointsX, const std::vector<double> &pointsY) {
-  return [=](double x) {
-    size_t stepIdx = firstSmallerOrEqual(x, pointsX);
-    return pointsY[stepIdx];
-  };
-}
-
-} // namespace reanimated::css
+#include <reanimated/CSS/easing/steps.h>
+
+#include <vector>
+
+namespace reanimated::css {
+EasingFunction steps(const std::vector<double> &pointsX, const std::vector<double> &pointsY) {
+  return [=](double x) {
+    size_t stepIdx = firstSmallerOrEqual(x, pointsX);
+    return pointsY[stepIdx];
+  };
+}
+
+} // namespace reanimated::css

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

@@ -1,12 +1,12 @@
-#pragma once
-
-#include <reanimated/CSS/common/definitions.h>
-#include <reanimated/CSS/utils/algorithms.h>
-
-#include <vector>
-
-namespace reanimated::css {
-
-EasingFunction steps(const std::vector<double> &pointsX, const std::vector<double> &pointsY);
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/definitions.h>
+#include <reanimated/CSS/utils/algorithms.h>
+
+#include <vector>
+
+namespace reanimated::css {
+
+EasingFunction steps(const std::vector<double> &pointsX, const std::vector<double> &pointsY);
+
+} // namespace reanimated::css

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

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