@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/transforms/TransformOperationInterpolator.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include <reanimated/CSS/interpolation/configs.h>
+#include <reanimated/CSS/interpolation/operations/StyleOperationInterpolator.h>
+#include <reanimated/CSS/interpolation/transforms/operations/matrix.h>
+#include <reanimated/CSS/interpolation/transforms/operations/perspective.h>
+
+#include <memory>
+#include <type_traits>
+
+namespace reanimated::css {
+    
+// Base implementation for simple operations
+template <typename TOperation, typename = void>
+class TransformOperationInterpolator : public StyleOperationInterpolator {
+ public:
+  using StyleOperationInterpolator::StyleOperationInterpolator;
+
+  std::unique_ptr<StyleOperation> interpolate(
+      double progress,
+      const std::shared_ptr<StyleOperation> &from,
+      const std::shared_ptr<StyleOperation> &to,
+      const StyleOperationsInterpolationContext &context) const override;
+};
+
+// Specialization for PerspectiveOperation
+template <>
+class TransformOperationInterpolator<PerspectiveOperation, void> : public StyleOperationInterpolator {
+ public:
+  explicit TransformOperationInterpolator(const std::shared_ptr<PerspectiveOperation> &defaultOperation);
+
+  std::unique_ptr<StyleOperation> interpolate(
+      double progress,
+      const std::shared_ptr<StyleOperation> &from,
+      const std::shared_ptr<StyleOperation> &to,
+      const StyleOperationsInterpolationContext &context) const override;
+};
+
+// Specialization for MatrixOperation
+template <>
+class TransformOperationInterpolator<MatrixOperation, void> : public StyleOperationInterpolator {
+ public:
+  explicit TransformOperationInterpolator(const std::shared_ptr<MatrixOperation> &defaultOperation);
+
+  std::unique_ptr<StyleOperation> interpolate(
+      double progress,
+      const std::shared_ptr<StyleOperation> &from,
+      const std::shared_ptr<StyleOperation> &to,
+      const StyleOperationsInterpolationContext &context) const override;
+
+ protected:
+  template <typename MatrixType>
+  MatrixType interpolateMatrix(double progress, const TransformMatrix::Shared &from, const TransformMatrix::Shared &to)
+      const;
+
+  TransformMatrix::Shared matrixFromOperation(
+      const std::shared_ptr<TransformOperation> &operation,
+      bool shouldBe3D,
+      const StyleOperationsInterpolationContext &context) const;
+};
+
+// Specialization for resolvable operations
+template <typename TOperation>
+class TransformOperationInterpolator<
+    TOperation,
+    std::enable_if_t<ResolvableOp<TOperation> && !std::is_same_v<TOperation, PerspectiveOperation> && !std::is_same_v<TOperation, MatrixOperation>>> : public StyleOperationInterpolator {
+ public:
+  TransformOperationInterpolator(
+      const std::shared_ptr<TOperation> &defaultOperation,
+      ResolvableValueInterpolatorConfig config);
+
+  std::unique_ptr<StyleOperation> interpolate(
+      double progress,
+      const std::shared_ptr<StyleOperation> &from,
+      const std::shared_ptr<StyleOperation> &to,
+      const StyleOperationsInterpolationContext &context) const override;
+
+  std::shared_ptr<StyleOperation> resolveOperation(
+      const std::shared_ptr<StyleOperation> &operation,
+      const StyleOperationsInterpolationContext &context) const override;
+
+ protected:
+  const ResolvableValueInterpolatorConfig config_;
+
+  ResolvableValueInterpolationContext getResolvableValueContext(
+      const StyleOperationsInterpolationContext &context) const;
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/interpolation/transforms/TransformsStyleInterpolator.cpp

@@ -0,0 +1,149 @@
+#include <reanimated/CSS/interpolation/transforms/TransformsStyleInterpolator.h>
+
+#include <unordered_map>
+
+namespace reanimated::css {
+
+const folly::dynamic defaultStyleValue = folly::dynamic::array(MatrixOperation(TransformMatrix3D()).toDynamic());
+
+TransformsStyleInterpolator::TransformsStyleInterpolator(
+    const PropertyPath &propertyPath,
+    const std::shared_ptr<StyleOperationInterpolators> &interpolators,
+    const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
+    : OperationsStyleInterpolatorBase<TransformOperation>(
+          propertyPath,
+          interpolators,
+          viewStylesRepository,
+          defaultStyleValue) {}
+
+void TransformsStyleInterpolator::addConvertedOperations(
+    const std::shared_ptr<TransformOperation> &sourceOperation,
+    const std::shared_ptr<TransformOperation> &targetOperation,
+    StyleOperations &sourceResult,
+    StyleOperations &targetResult) const {
+  const auto convertedOps = sourceOperation->convertTo(static_cast<TransformOp>(targetOperation->type));
+
+  targetResult.emplace_back(targetOperation);
+  for (size_t k = 0; k < convertedOps.size(); ++k) {
+    sourceResult.emplace_back(convertedOps[k]);
+    // Converted operations will contain one operation with the same type and
+    // can contain more operations derived from the source operation (we need
+    // to pair them with operations of the same type with default values)
+    if (k > 0) {
+      targetResult.emplace_back(getDefaultOperationOfType(convertedOps[k]->type));
+    }
+  }
+}
+
+std::optional<std::pair<StyleOperations, StyleOperations>> TransformsStyleInterpolator::createInterpolationPair(
+    const StyleOperations &fromOperations,
+    const StyleOperations &toOperations) const {
+  StyleOperations fromOperationsResult, toOperationsResult;
+  size_t i = 0, j = 0;
+  bool shouldInterpolateMatrices = false;
+
+  // Build index maps and check for matrix operation
+  std::unordered_map<uint8_t, size_t> lastIndexInFrom, lastIndexInTo;
+  for (size_t idx = 0; idx < fromOperations.size(); ++idx) {
+    if (static_cast<TransformOp>(fromOperations[idx]->type) == TransformOp::Matrix) {
+      shouldInterpolateMatrices = true;
+      break;
+    }
+    lastIndexInFrom[fromOperations[idx]->type] = idx;
+  }
+  for (size_t idx = 0; idx < toOperations.size() && !shouldInterpolateMatrices; ++idx) {
+    if (static_cast<TransformOp>(toOperations[idx]->type) == TransformOp::Matrix) {
+      shouldInterpolateMatrices = true;
+      break;
+    }
+    lastIndexInTo[toOperations[idx]->type] = idx;
+  }
+
+  while (!shouldInterpolateMatrices && i < fromOperations.size() && j < toOperations.size()) {
+    const auto &fromOperation = std::static_pointer_cast<TransformOperation>(fromOperations[i]);
+    const auto &toOperation = std::static_pointer_cast<TransformOperation>(toOperations[j]);
+    const auto fromType = static_cast<TransformOp>(fromOperation->type);
+    const auto toType = static_cast<TransformOp>(toOperation->type);
+
+    // Case 1: Types match directly
+    if (fromType == toType) {
+      fromOperationsResult.emplace_back(fromOperation);
+      toOperationsResult.emplace_back(toOperation);
+      i++;
+      j++;
+    } else if (fromOperation->canConvertTo(toType)) {
+      // Case 2: Operations can be converted to each other's type
+      addConvertedOperations(fromOperation, toOperation, fromOperationsResult, toOperationsResult);
+      i++;
+      j++;
+    } else if (toOperation->canConvertTo(fromType)) {
+      addConvertedOperations(toOperation, fromOperation, toOperationsResult, fromOperationsResult);
+      i++;
+      j++;
+    } else {
+      if (fromType == TransformOp::Perspective || toType == TransformOp::Perspective) {
+        shouldInterpolateMatrices = true;
+        break;
+      }
+      // Case 3: Use default values if no conversion possible
+      bool toExistsLaterInFrom = lastIndexInFrom.count(toOperation->type) && lastIndexInFrom[toOperation->type] > i;
+      bool fromExistsLaterInTo = lastIndexInTo.count(fromOperation->type) && lastIndexInTo[fromOperation->type] > j;
+
+      if (toExistsLaterInFrom == fromExistsLaterInTo) {
+        // If neither exists later, or both exist later (were reordered), we
+        // cannot interpolate the operations directly and we need to convert
+        // these operations to matrices
+        shouldInterpolateMatrices = true;
+        break;
+      } else if (!fromExistsLaterInTo) {
+        // If fromOperation does not exist later in toOperations, we can
+        // interpolate it to the default value
+        fromOperationsResult.emplace_back(fromOperation);
+        toOperationsResult.emplace_back(getDefaultOperationOfType(fromOperation->type));
+        i++;
+      } else {
+        // If toOperation does not exist later in fromOperations, we can
+        // interpolate it from the default value
+        fromOperationsResult.emplace_back(getDefaultOperationOfType(toOperation->type));
+        toOperationsResult.emplace_back(toOperation);
+        j++;
+      }
+    }
+  }
+
+  // Convert all operations to matrices if matrix interpolation is required
+  if (shouldInterpolateMatrices) {
+    return std::make_pair(
+        StyleOperations{std::make_shared<MatrixOperation>(convertToTransformOperations(fromOperations))},
+        StyleOperations{std::make_shared<MatrixOperation>(convertToTransformOperations(toOperations))});
+  }
+
+  // Add remaining operations with default values
+  for (; i < fromOperations.size(); ++i) {
+    fromOperationsResult.emplace_back(fromOperations[i]);
+    toOperationsResult.emplace_back(getDefaultOperationOfType(fromOperations[i]->type));
+  }
+  for (; j < toOperations.size(); ++j) {
+    fromOperationsResult.emplace_back(getDefaultOperationOfType(toOperations[j]->type));
+    toOperationsResult.emplace_back(toOperations[j]);
+  }
+
+  return std::make_pair(fromOperationsResult, toOperationsResult);
+}
+
+TransformOperations TransformsStyleInterpolator::convertToTransformOperations(const StyleOperations &operations) const {
+  TransformOperations result;
+  result.reserve(operations.size());
+
+  for (const auto &operation : operations) {
+    result.emplace_back(std::static_pointer_cast<TransformOperation>(operation));
+  }
+
+  return result;
+}
+
+std::shared_ptr<TransformOperation> TransformsStyleInterpolator::getDefaultOperationOfType(const uint8_t type) const {
+  return std::static_pointer_cast<TransformOperation>(interpolators_->at(type)->getDefaultOperation());
+}
+
+} // namespace reanimated::css

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

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <reanimated/CSS/interpolation/operations/OperationsStyleInterpolator.h>
+#include <reanimated/CSS/interpolation/transforms/TransformOperationInterpolator.h>
+
+#include <memory>
+#include <utility>
+
+namespace reanimated::css {
+
+class TransformsStyleInterpolator final : public OperationsStyleInterpolatorBase<TransformOperation> {
+ public:
+  TransformsStyleInterpolator(
+      const PropertyPath &propertyPath,
+      const std::shared_ptr<StyleOperationInterpolators> &interpolators,
+      const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
+
+ protected:
+  std::optional<std::pair<StyleOperations, StyleOperations>> createInterpolationPair(
+      const StyleOperations &fromOperations,
+      const StyleOperations &toOperations) const override;
+
+ private:
+  void addConvertedOperations(
+      const std::shared_ptr<TransformOperation> &sourceOperation,
+      const std::shared_ptr<TransformOperation> &targetOperation,
+      StyleOperations &sourceResult,
+      StyleOperations &targetResult) const;
+  TransformOperations convertToTransformOperations(const StyleOperations &operations) const;
+  std::shared_ptr<TransformOperation> getDefaultOperationOfType(uint8_t type) const;
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,208 @@
+#include <reanimated/CSS/interpolation/transforms/TransformOperationInterpolator.h>
+#include <reanimated/CSS/interpolation/transforms/operations/matrix.h>
+
+#include <deque>
+#include <memory>
+#include <utility>
+
+namespace reanimated::css {
+
+TransformMatrix3D matrixFromOperations3D(TransformOperations &operations) {
+  TransformMatrix3D result;
+  for (int i = static_cast<int>(operations.size()) - 1; i >= 0; i--) {
+    result *= static_cast<const TransformMatrix3D &>(*operations[i]->toMatrix(true));
+  }
+  return result;
+}
+
+TransformMatrix2D matrixFromOperations2D(TransformOperations &operations) {
+  TransformMatrix2D result;
+  for (int i = static_cast<int>(operations.size()) - 1; i >= 0; i--) {
+    result *= static_cast<const TransformMatrix2D &>(*operations[i]->toMatrix(false));
+  }
+  return result;
+}
+
+std::pair<TransformOperations, bool> flattenOperations(const TransformOperations &operations) {
+  std::deque<std::shared_ptr<TransformOperation>> unprocessedQueue(operations.begin(), operations.end());
+  TransformOperations result;
+  bool is3D = false;
+
+  while (!unprocessedQueue.empty()) {
+    const auto operation = unprocessedQueue.front();
+    unprocessedQueue.pop_front();
+
+    if (operation->type == static_cast<uint8_t>(TransformOp::Matrix)) {
+      const auto matrixOperation = std::static_pointer_cast<MatrixOperation>(operation);
+      if (std::holds_alternative<TransformOperations>(matrixOperation->value)) {
+        // If the current operation is a matrix created from other operations,
+        // add all of these operations at the beginning of the queue
+        const auto &nestedOps = std::get<TransformOperations>(matrixOperation->value);
+        unprocessedQueue.insert(unprocessedQueue.begin(), nestedOps.begin(), nestedOps.end());
+        continue;
+      }
+    }
+
+    if (operation->is3D()) {
+      is3D = true;
+    }
+
+    result.emplace_back(operation);
+  }
+
+  return {std::move(result), is3D};
+}
+
+/**
+ * Simplifies the vector of operations by converting to matrices and multiplying
+ * transformations that can be converted. This reduces the number of operations
+ * in the resulting operations vector or returns a single matrix if all
+ * operations can be converted to a matrix.
+ */
+std::pair<MatrixOperationValue, bool> simplifyOperations(const TransformOperations &operations) {
+  const auto [flattenedOperations, is3D] = flattenOperations(operations);
+
+  TransformOperations result;
+  TransformOperations toSimplify;
+  result.reserve(operations.size());
+  toSimplify.reserve(operations.size());
+
+//  const auto simplify = [&]() {
+//    return is3D ? std::make_shared<MatrixOperation>(matrixFromOperations3D(toSimplify))
+//                : std::make_shared<MatrixOperation>(matrixFromOperations2D(toSimplify));
+//  };
+   //TODO
+  const auto simplify = [](TransformOperations &toSimplify,bool is3DValue) {
+    return is3DValue ? std::make_shared<MatrixOperation>(matrixFromOperations3D(toSimplify))
+                : std::make_shared<MatrixOperation>(matrixFromOperations2D(toSimplify));
+  };
+  for (const auto &operation : flattenedOperations) {
+    if (operation->shouldResolve()) {
+      if (toSimplify.size() > 0) {
+        result.emplace_back(simplify(toSimplify,is3D));
+        toSimplify.clear();
+      }
+
+      // Keep operations that need to be resolved unchanged in the transform
+      // operations vector
+      result.emplace_back(operation);
+    } else {
+      toSimplify.emplace_back(operation);
+    }
+  }
+
+  // Result is empty only if there was not a single operation that needed to be
+  // resolved (all operations were added to the toSimplify vector)
+  if (result.empty()) {
+    return {simplify(toSimplify,is3D)->toMatrix(is3D), is3D};
+  }
+
+  result.emplace_back(simplify(toSimplify,is3D));
+
+  return {std::move(result), is3D};
+}
+
+MatrixOperation::MatrixOperation(MatrixOperationValue value)
+    : TransformOperation(TransformOp::Matrix), value(std::move(value)) {
+  // Initialize is3D_ based on the variant content
+  if (std::holds_alternative<TransformMatrix::Shared>(this->value)) {
+    const auto &matrix = std::get<TransformMatrix::Shared>(this->value);
+    is3D_ = matrix->getDimension() == MATRIX_3D_DIMENSION;
+  } else {
+    // If it contains TransformOperations, check if any operation is 3D
+    const auto &operations = std::get<TransformOperations>(this->value);
+    is3D_ = false;
+    for (const auto &operation : operations) {
+      if (operation->is3D()) {
+        is3D_ = true;
+        break;
+      }
+    }
+  }
+}
+
+MatrixOperation::MatrixOperation(jsi::Runtime &rt, const jsi::Value &value)
+    : MatrixOperation([&]() -> TransformMatrix::Shared {
+        // Try 2D first, then 3D (will throw if neither works)
+        if (TransformMatrix2D::canConstruct(rt, value)) {
+          is3D_ = false;
+          return std::make_shared<const TransformMatrix2D>(rt, value);
+        }
+        is3D_ = true;
+        return std::make_shared<const TransformMatrix3D>(rt, value);
+      }()) {}
+
+MatrixOperation::MatrixOperation(const folly::dynamic &value)
+    : MatrixOperation([&]() -> TransformMatrix::Shared {
+        // Try 2D first, then 3D (will throw if neither works)
+        if (TransformMatrix2D::canConstruct(value)) {
+          is3D_ = false;
+          return std::make_shared<const TransformMatrix2D>(value);
+        }
+        is3D_ = true;
+        return std::make_shared<const TransformMatrix3D>(value);
+      }()) {}
+
+MatrixOperation::MatrixOperation(TransformMatrix2D matrix)
+    : TransformOperation(TransformOp::Matrix),
+      value(std::make_shared<const TransformMatrix2D>(std::move(matrix))),
+      is3D_(false) {}
+
+MatrixOperation::MatrixOperation(TransformMatrix3D matrix)
+    : TransformOperation(TransformOp::Matrix),
+      value(std::make_shared<const TransformMatrix3D>(std::move(matrix))),
+      is3D_(true) {}
+
+MatrixOperation::MatrixOperation(TransformOperations operations)
+    // Simplify operations to reduce the number of matrix
+    // multiplications during matrix keyframe interpolation
+    : TransformOperation(TransformOp::Matrix), value([&]() {
+        const auto &[value, is3D] = simplifyOperations(operations);
+        is3D_ = is3D;
+        return value;
+      }()) {}
+
+bool MatrixOperation::is3D() const {
+  return is3D_;
+}
+
+folly::dynamic MatrixOperation::valueToDynamic() const {
+  return getMatrixFromVariant()->toDynamic();
+}
+
+TransformMatrix::Shared MatrixOperation::toMatrix(const bool force3D) const {
+  const auto &storedMatrix = getMatrixFromVariant();
+
+  if (force3D && storedMatrix->getDimension() == MATRIX_2D_DIMENSION) {
+    return std::make_shared<const TransformMatrix3D>(
+        TransformMatrix3D::from2D(static_cast<const TransformMatrix2D &>(*storedMatrix)));
+  }
+
+  return storedMatrix;
+}
+
+const TransformMatrix::Shared &MatrixOperation::getMatrixFromVariant() const {
+  if (!std::holds_alternative<TransformMatrix::Shared>(value)) {
+    throw std::runtime_error("[Reanimated] Cannot convert unprocessed transform operations to the matrix.");
+  }
+  return std::get<TransformMatrix::Shared>(value);
+}
+
+bool MatrixOperation::areValuesEqual(const StyleOperation &other) const {
+  const auto &otherOperation = static_cast<const MatrixOperation &>(other);
+
+  // Quick check: if variants have different types, they're not equal
+  if (value.index() != otherOperation.value.index()) {
+    return false;
+  }
+
+  // Both hold TransformOperations
+  if (std::holds_alternative<TransformOperations>(value)) {
+    return std::get<TransformOperations>(value) == std::get<TransformOperations>(otherOperation.value);
+  }
+
+  // Both hold matrices
+  return *std::get<TransformMatrix::Shared>(value) == *std::get<TransformMatrix::Shared>(otherOperation.value);
+}
+
+} // namespace reanimated::css

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

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <reanimated/CSS/common/transforms/TransformMatrix2D.h>
+#include <reanimated/CSS/common/transforms/TransformMatrix3D.h>
+#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
+
+#include <utility>
+#include <variant>
+
+namespace reanimated::css {
+
+// MatrixOperationValue type for matrix operations
+using MatrixOperationValue = std::variant<TransformMatrix::Shared, TransformOperations>;
+
+/**
+ * Multiplies all operations in the vector to a single 3D matrix
+ * @param operations - the vector of operations that can be represented in 3D
+ */
+TransformMatrix3D matrixFromOperations3D(TransformOperations &operations);
+
+/**
+ * Multiplies all operations in the vector to a single 2D matrix
+ * @param operations - the vector of operations that can be represented in 2D
+ */
+TransformMatrix2D matrixFromOperations2D(TransformOperations &operations);
+
+/**
+ * MatrixOperation does not inherit from TransformOperationBase because its value type
+ * is different from the other transform operations which use a CSSValue-derived type.
+ * Instead, it uses a variant of TransformMatrix::Shared and TransformOperations that
+ * doesn't have a value field.
+ */
+struct MatrixOperation final : public TransformOperation {
+  const MatrixOperationValue value;
+
+  explicit MatrixOperation(MatrixOperationValue value);
+  explicit MatrixOperation(jsi::Runtime &rt, const jsi::Value &value);
+  explicit MatrixOperation(const folly::dynamic &value);
+  explicit MatrixOperation(TransformMatrix2D matrix);
+  explicit MatrixOperation(TransformMatrix3D matrix);
+  explicit MatrixOperation(TransformOperations operations);
+
+  bool is3D() const override;
+  folly::dynamic valueToDynamic() const override;
+  TransformMatrix::Shared toMatrix(bool force3D) const override;
+
+ protected:
+  bool areValuesEqual(const StyleOperation &other) const override;
+
+ private:
+  bool is3D_;
+
+  const TransformMatrix::Shared &getMatrixFromVariant() const;
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,42 @@
+#include <reanimated/CSS/common/transforms/TransformMatrix3D.h>
+#include <reanimated/CSS/interpolation/transforms/operations/perspective.h>
+
+#include <algorithm>
+#include <cmath>
+#include <memory>
+
+namespace reanimated::css {
+
+double sanitizePerspectiveValue(double value) {
+  if (value < 0) {
+    // Round value between -1 and 0 to -1
+    return std::min(value, -1.0);
+  }
+  // Round value between 0 and 1 to 1
+  return std::max(value, 1.0);
+}
+
+PerspectiveOperation::PerspectiveOperation(const double value)
+    : TransformOperationBase<TransformOp::Perspective, CSSDouble>(CSSDouble(sanitizePerspectiveValue(value))) {}
+
+bool PerspectiveOperation::is3D() const {
+  return true;
+}
+
+folly::dynamic PerspectiveOperation::valueToDynamic() const {
+  if (std::isinf(value.value)) {
+    return folly::dynamic();
+  }
+  return value.toDynamic();
+}
+
+TransformMatrix::Shared PerspectiveOperation::toMatrix(bool /* force3D */) const {
+  if (!cachedMatrix_) {
+    // Perspective is a 3D operation
+    cachedMatrix_ =
+        std::make_shared<const TransformMatrix3D>(TransformMatrix3D::create<TransformOp::Perspective>(value.value));
+  }
+  return cachedMatrix_;
+}
+
+} // namespace reanimated::css

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

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSNumber.h>
+#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
+
+#include <memory>
+
+namespace reanimated::css {
+
+struct PerspectiveOperation final : public TransformOperationBase<TransformOp::Perspective, CSSDouble> {
+  using TransformOperationBase<TransformOp::Perspective, CSSDouble>::TransformOperationBase;
+
+  explicit PerspectiveOperation(double value);
+
+  bool is3D() const override;
+  folly::dynamic valueToDynamic() const override;
+  TransformMatrix::Shared toMatrix(bool /* force3D */) const override;
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,41 @@
+#include <reanimated/CSS/common/transforms/TransformMatrix3D.h>
+#include <reanimated/CSS/interpolation/transforms/operations/rotate.h>
+
+#include <memory>
+#include <string>
+
+namespace reanimated::css {
+
+template <TransformOp TOperation>
+RotateOperationBase2D<TOperation>::RotateOperationBase2D(const std::string &value)
+    : TransformOperationBase<TOperation, CSSAngle>(CSSAngle(value)) {}
+
+template <TransformOp TOperation>
+RotateOperationBase3D<TOperation>::RotateOperationBase3D(const std::string &value)
+    : TransformOperationBase<TOperation, CSSAngle>(CSSAngle(value)) {}
+
+template <TransformOp TOperation>
+bool RotateOperationBase3D<TOperation>::is3D() const {
+  return true;
+}
+
+template <TransformOp TOperation>
+TransformMatrix::Shared RotateOperationBase3D<TOperation>::toMatrix(bool /* force3D */) const {
+  return std::make_shared<const TransformMatrix3D>(TransformMatrix3D::create<TOperation>(this->value.value));
+}
+
+bool RotateZOperation::canConvertTo(TransformOp type) const {
+  return type == TransformOp::Rotate;
+}
+
+TransformOperations RotateZOperation::convertTo(TransformOp type) const {
+  assertCanConvertTo(type);
+  return {std::make_shared<RotateOperation>(value)};
+}
+
+template struct RotateOperationBase2D<TransformOp::Rotate>;
+template struct RotateOperationBase2D<TransformOp::RotateZ>;
+template struct RotateOperationBase3D<TransformOp::RotateX>;
+template struct RotateOperationBase3D<TransformOp::RotateY>;
+
+} // namespace reanimated::css

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

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <reanimated/CSS/common/transforms/TransformMatrix.h>
+#include <reanimated/CSS/common/values/CSSAngle.h>
+#include <reanimated/CSS/interpolation/transforms/TransformOperation.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+template <TransformOp TOperation>
+struct RotateOperationBase2D : public TransformOperationBase<TOperation, CSSAngle> {
+  using TransformOperationBase<TOperation, CSSAngle>::TransformOperationBase;
+
+  explicit RotateOperationBase2D(const std::string &value);
+};
+
+template <TransformOp TOperation>
+struct RotateOperationBase3D : public TransformOperationBase<TOperation, CSSAngle> {
+  using TransformOperationBase<TOperation, CSSAngle>::TransformOperationBase;
+
+  explicit RotateOperationBase3D(const std::string &value);
+
+  bool is3D() const override;
+  TransformMatrix::Shared toMatrix(bool /* force3D */) const override;
+};
+
+using RotateOperation = RotateOperationBase2D<TransformOp::Rotate>;
+using RotateXOperation = RotateOperationBase3D<TransformOp::RotateX>;
+using RotateYOperation = RotateOperationBase3D<TransformOp::RotateY>;
+
+struct RotateZOperation final : public RotateOperationBase2D<TransformOp::RotateZ> {
+  using RotateOperationBase2D<TransformOp::RotateZ>::RotateOperationBase2D;
+
+  bool canConvertTo(TransformOp type) const override;
+  TransformOperations convertTo(TransformOp type) const override;
+};
+
+} // namespace reanimated::css