@react-native-ohos/react-native-reanimated 3.18.2-rc.2 → 4.0.0-rc.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/common/transforms/TransformMatrix.cpp

@@ -0,0 +1,166 @@
+#include <reanimated/CSS/common/transforms/TransformMatrix.h>
+
+#include <reanimated/CSS/common/transforms/TransformMatrix2D.h>
+#include <reanimated/CSS/common/transforms/TransformMatrix3D.h>
+
+#include <algorithm>
+#include <string>
+#include <utility>
+
+namespace reanimated::css {
+
+// TransformMatrixBase template implementations
+template <typename TDerived, size_t TDimension>
+TransformMatrixBase<TDerived, TDimension>::TransformMatrixBase() : TransformMatrix(), matrix_{} {
+  // Create an identity matrix
+  for (size_t i = 0; i < TDimension; ++i) {
+    matrix_[i * (TDimension + 1)] = 1;
+  }
+}
+
+template <typename TDerived, size_t TDimension>
+TransformMatrixBase<TDerived, TDimension>::TransformMatrixBase(MatrixArray matrix)
+    : TransformMatrix(), matrix_(std::move(matrix)) {}
+
+template <typename TDerived, size_t TDimension>
+TransformMatrixBase<TDerived, TDimension>::TransformMatrixBase(const TransformMatrixBase &other)
+    : TransformMatrix(), matrix_(other.matrix_) {}
+
+template <typename TDerived, size_t TDimension>
+TransformMatrixBase<TDerived, TDimension>::TransformMatrixBase(TransformMatrixBase &&other) noexcept
+    : TransformMatrix(), matrix_(std::move(other.matrix_)) {}
+
+template <typename TDerived, size_t TDimension>
+bool TransformMatrixBase<TDerived, TDimension>::operator==(const TDerived &other) const {
+  return matrix_ == other.matrix_;
+}
+
+template <typename TDerived, size_t TDimension>
+bool TransformMatrixBase<TDerived, TDimension>::operator==(const TransformMatrix &other) const {
+  return TDimension == other.getDimension() && matrix_ == static_cast<const TDerived &>(other).matrix_;
+}
+
+template <typename TDerived, size_t TDimension>
+double &TransformMatrixBase<TDerived, TDimension>::operator[](size_t index) {
+  return matrix_[index];
+}
+
+template <typename TDerived, size_t TDimension>
+const double &TransformMatrixBase<TDerived, TDimension>::operator[](size_t index) const {
+  return matrix_[index];
+}
+
+template <typename TDerived, size_t TDimension>
+size_t TransformMatrixBase<TDerived, TDimension>::getDimension() const {
+  return TDimension;
+}
+
+template <typename TDerived, size_t TDimension>
+size_t TransformMatrixBase<TDerived, TDimension>::getSize() const {
+  return SIZE;
+}
+
+template <typename TDerived, size_t TDimension>
+bool TransformMatrixBase<TDerived, TDimension>::isSingular() const {
+  return determinant() == 0;
+}
+
+template <typename TDerived, size_t TDimension>
+bool TransformMatrixBase<TDerived, TDimension>::normalize() {
+  const auto last = matrix_[SIZE - 1];
+  if (last == 0) {
+    return false;
+  }
+  if (last == 1) {
+    return true;
+  }
+
+  for (size_t i = 0; i < SIZE; ++i) {
+    matrix_[i] /= last;
+  }
+  return true;
+}
+
+template <typename TDerived, size_t TDimension>
+void TransformMatrixBase<TDerived, TDimension>::transpose() {
+  for (size_t i = 0; i < TDimension; ++i) {
+    for (size_t j = i + 1; j < TDimension; ++j) {
+      std::swap(matrix_[i * TDimension + j], matrix_[j * TDimension + i]);
+    }
+  }
+}
+
+template <typename TDerived, size_t TDimension>
+std::string TransformMatrixBase<TDerived, TDimension>::toString() const {
+  std::string result = "[";
+  for (size_t i = 0; i < SIZE; ++i) {
+    result += std::to_string(matrix_[i]);
+    if (i < SIZE - 1) {
+      result += ", ";
+    }
+  }
+  result += "]";
+  return result;
+}
+
+template <typename TDerived, size_t TDimension>
+folly::dynamic TransformMatrixBase<TDerived, TDimension>::toDynamic() const {
+  folly::dynamic result = folly::dynamic::array;
+  for (size_t i = 0; i < SIZE; ++i) {
+    result.push_back(matrix_[i]);
+  }
+  return result;
+}
+
+template <typename TDerived, size_t TDimension>
+TDerived TransformMatrixBase<TDerived, TDimension>::operator*(const TDerived &rhs) const {
+  return TDerived(multiply(rhs));
+}
+
+template <typename TDerived, size_t TDimension>
+TDerived &TransformMatrixBase<TDerived, TDimension>::operator*=(const TDerived &rhs) {
+  matrix_ = multiply(rhs);
+  return static_cast<TDerived &>(*this);
+}
+
+template <typename TDerived, size_t TDimension>
+TransformMatrixBase<TDerived, TDimension> &TransformMatrixBase<TDerived, TDimension>::operator=(
+    const TransformMatrixBase &other) {
+  if (this != &other) {
+    // Note: dimension_ is const, so we can't reassign it
+    // But since all instances have the same dimension, this is fine
+    matrix_ = other.matrix_;
+  }
+  return *this;
+}
+
+template <typename TDerived, size_t TDimension>
+TransformMatrixBase<TDerived, TDimension> &TransformMatrixBase<TDerived, TDimension>::operator=(
+    TransformMatrixBase &&other) noexcept {
+  if (this != &other) {
+    matrix_ = std::move(other.matrix_);
+  }
+  return *this;
+}
+
+template <typename TDerived, size_t TDimension>
+typename TransformMatrixBase<TDerived, TDimension>::MatrixArray TransformMatrixBase<TDerived, TDimension>::multiply(
+    const TDerived &rhs) const {
+  MatrixArray result{};
+
+  for (size_t i = 0; i < TDimension; ++i) {
+    for (size_t k = 0; k < TDimension; ++k) {
+      double temp = matrix_[i * TDimension + k];
+      for (size_t j = 0; j < TDimension; ++j) {
+        result[i * TDimension + j] += temp * rhs[k * TDimension + j];
+      }
+    }
+  }
+
+  return result;
+}
+
+template class TransformMatrixBase<TransformMatrix2D, MATRIX_2D_DIMENSION>;
+template class TransformMatrixBase<TransformMatrix3D, MATRIX_3D_DIMENSION>;
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/common/transforms/TransformMatrix.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <reanimated/CSS/common/definitions.h>
+
+#include <folly/dynamic.h>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace reanimated::css {
+
+class TransformMatrix {
+ public:
+  using Shared = std::shared_ptr<const TransformMatrix>;
+
+  TransformMatrix() = default;
+  virtual ~TransformMatrix() = default;
+
+  virtual size_t getDimension() const = 0;
+  virtual size_t getSize() const = 0;
+
+  virtual bool isSingular() const = 0;
+  virtual bool normalize() = 0;
+  virtual void transpose() = 0;
+  virtual double determinant() const = 0;
+
+  virtual std::string toString() const = 0;
+  virtual folly::dynamic toDynamic() const = 0;
+
+  virtual double &operator[](size_t index) = 0;
+  virtual const double &operator[](size_t index) const = 0;
+  virtual bool operator==(const TransformMatrix &other) const = 0;
+};
+
+template <typename TDerived, size_t TDimension>
+class TransformMatrixBase : public TransformMatrix {
+ public:
+  static constexpr size_t SIZE = TDimension * TDimension;
+  using MatrixArray = std::array<double, SIZE>;
+
+  TransformMatrixBase();
+  explicit TransformMatrixBase(MatrixArray matrix);
+  TransformMatrixBase(const TransformMatrixBase &other);
+  TransformMatrixBase(TransformMatrixBase &&other) noexcept;
+
+  bool operator==(const TDerived &other) const;
+  bool operator==(const TransformMatrix &other) const override;
+  double &operator[](size_t index) override;
+  const double &operator[](size_t index) const override;
+
+  size_t getDimension() const override;
+  size_t getSize() const override;
+  bool isSingular() const override;
+  bool normalize() override;
+  void transpose() override;
+  std::string toString() const override;
+  folly::dynamic toDynamic() const override;
+
+  TDerived operator*(const TDerived &rhs) const;
+  TDerived &operator*=(const TDerived &rhs);
+
+  TransformMatrixBase &operator=(const TransformMatrixBase &other);
+  TransformMatrixBase &operator=(TransformMatrixBase &&other) noexcept;
+
+ protected:
+  std::array<double, SIZE> matrix_;
+
+  MatrixArray multiply(const TDerived &rhs) const;
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/common/transforms/TransformMatrix2D.cpp

@@ -0,0 +1,368 @@
+#include <reanimated/CSS/common/transforms/TransformMatrix2D.h>
+
+#include <cmath>
+
+namespace reanimated::css {
+
+TransformMatrix2D::TransformMatrix2D(jsi::Runtime &rt, const jsi::Value &value)
+    : TransformMatrixBase<TransformMatrix2D, MATRIX_2D_DIMENSION>() {
+  const auto &array = value.asObject(rt).asArray(rt);
+  const auto size = array.size(rt);
+
+  if (size == SIZE) {
+    // Direct 3x3 matrix
+    for (size_t i = 0; i < SIZE; ++i) {
+      matrix_[i] = array.getValueAtIndex(rt, i).asNumber();
+    }
+  } else if (size == 16) {
+    // Convert 4x4 matrix to 3x3
+    // (we should call canConstruct first to ensure that the matrix is
+    // convertible to 3x3)
+    //
+    // [m[0], m[1], 0, m[2]]     [m[0], m[1], m[2]]
+    // [m[3], m[4], 0, m[5]]  -> [m[3], m[4], m[5]]
+    // [  0,   0,  1,   0]       [m[6], m[7], m[8]]
+    // [m[6], m[7], 0, m[8]]
+    matrix_[0] = array.getValueAtIndex(rt, 0).asNumber();
+    matrix_[1] = array.getValueAtIndex(rt, 1).asNumber();
+    matrix_[2] = array.getValueAtIndex(rt, 3).asNumber();
+    matrix_[3] = array.getValueAtIndex(rt, 4).asNumber();
+    matrix_[4] = array.getValueAtIndex(rt, 5).asNumber();
+    matrix_[5] = array.getValueAtIndex(rt, 7).asNumber();
+    matrix_[6] = array.getValueAtIndex(rt, 12).asNumber();
+    matrix_[7] = array.getValueAtIndex(rt, 13).asNumber();
+    matrix_[8] = array.getValueAtIndex(rt, 15).asNumber();
+  } else {
+    throw std::invalid_argument("[Reanimated] TransformMatrix2D: Invalid matrix size: " + std::to_string(size));
+  }
+}
+
+TransformMatrix2D::TransformMatrix2D(const folly::dynamic &array)
+    : TransformMatrixBase<TransformMatrix2D, MATRIX_2D_DIMENSION>() {
+  const auto size = array.size();
+
+  if (size == SIZE) {
+    // Direct 3x3 matrix
+    for (size_t i = 0; i < SIZE; ++i) {
+      matrix_[i] = array[i].asDouble();
+    }
+  } else if (size == 16) {
+    // Convert 4x4 matrix to 3x3
+    // (we should call canConstruct first to ensure that the matrix is
+    // convertible to 3x3)
+    //
+    // [m[0], m[1], 0, m[2]]     [m[0], m[1], m[2]]
+    // [m[3], m[4], 0, m[5]]  -> [m[3], m[4], m[5]]
+    // [  0,   0,  1,   0]       [m[6], m[7], m[8]]
+    // [m[6], m[7], 0, m[8]]
+    matrix_[0] = array[0].asDouble();
+    matrix_[1] = array[1].asDouble();
+    matrix_[2] = array[3].asDouble();
+    matrix_[3] = array[4].asDouble();
+    matrix_[4] = array[5].asDouble();
+    matrix_[5] = array[7].asDouble();
+    matrix_[6] = array[12].asDouble();
+    matrix_[7] = array[13].asDouble();
+    matrix_[8] = array[15].asDouble();
+  } else {
+    throw std::invalid_argument("[Reanimated] TransformMatrix2D: Invalid matrix size: " + std::to_string(size));
+  }
+}
+
+bool TransformMatrix2D::canConstruct(jsi::Runtime &rt, const jsi::Value &value) {
+  if (!value.isObject()) {
+    return false;
+  }
+
+  const auto &obj = value.asObject(rt);
+  if (!obj.isArray(rt)) {
+    return false;
+  }
+
+  const auto &array = obj.asArray(rt);
+  const auto size = array.size(rt);
+
+  // Check if it's a 3x3 matrix (9 elements)
+  if (size == 9) {
+    return true;
+  }
+
+  // Check if it's a 4x4 matrix (16 elements) that can be converted to 2D
+  if (size == 16) {
+    // A 4x4 matrix can be converted to 2D if it has this pattern
+    // (where x means any number)
+    // [x, x, 0, x]
+    // [x, x, 0, x]
+    // [0, 0, 1, 0]
+    // [x, x, 0, x]
+    return array.getValueAtIndex(rt, 2).asNumber() == 0.0 && array.getValueAtIndex(rt, 6).asNumber() == 0.0 &&
+        array.getValueAtIndex(rt, 10).asNumber() == 1.0 && array.getValueAtIndex(rt, 11).asNumber() == 0.0 &&
+        array.getValueAtIndex(rt, 14).asNumber() == 0.0 && array.getValueAtIndex(rt, 15).asNumber() == 1.0;
+  }
+
+  return false;
+}
+
+bool TransformMatrix2D::canConstruct(const folly::dynamic &array) {
+  if (!array.isArray()) {
+    return false;
+  }
+  const auto size = array.size();
+
+  // Check if it's a 3x3 matrix (9 elements)
+  if (size == 9) {
+    return true;
+  }
+
+  // Check if it's a 4x4 matrix (16 elements) that can be converted to 2D
+  if (size == 16) {
+    // A 4x4 matrix can be converted to 2D if it has this pattern:
+    // (where x means any number)
+    // [x, x, 0, x]
+    // [x, x, 0, x]
+    // [0, 0, 1, 0]
+    // [x, x, 0, x]
+    return array[2].asDouble() == 0.0 && array[6].asDouble() == 0.0 && array[10].asDouble() == 1.0 &&
+        array[11].asDouble() == 0.0 && array[14].asDouble() == 0.0 && array[15].asDouble() == 1.0;
+  }
+
+  return false;
+}
+
+TransformMatrix2D::Decomposed TransformMatrix2D::Decomposed::interpolate(
+    const double progress,
+    const TransformMatrix2D::Decomposed &target) const {
+  // Compute shortest signed angular delta (in range −π..π]
+  const double angleDelta = std::remainder(target.rotation - rotation, 2.0 * M_PI);
+
+  return {
+      .scale = scale.interpolate(progress, target.scale),
+      .skew = skew + (target.skew - skew) * progress,
+      .rotation = rotation + progress * angleDelta,
+      .translation = translation.interpolate(progress, target.translation),
+  };
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const TransformMatrix2D::Decomposed &decomposed) {
+  os << "TransformMatrix2D::Decomposed(scale=" << decomposed.scale << ", skew=" << decomposed.skew
+     << ", rotation=" << decomposed.rotation << ", translation=" << decomposed.translation << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+template <>
+TransformMatrix2D TransformMatrix2D::create<TransformOp::Rotate>(double v) {
+  const auto cosVal = std::cos(v);
+  const auto sinVal = std::sin(v);
+  // clang-format off
+  return TransformMatrix2D({
+     cosVal, sinVal, 0,
+    -sinVal, cosVal, 0,
+          0,      0, 1
+  });
+  // clang-format on
+}
+
+template <>
+TransformMatrix2D TransformMatrix2D::create<TransformOp::Scale>(double v) {
+  // clang-format off
+  return TransformMatrix2D({
+    v, 0, 0,
+    0, v, 0,
+    0, 0, 1
+  });
+  // clang-format on
+}
+
+template <>
+TransformMatrix2D TransformMatrix2D::create<TransformOp::ScaleX>(double v) {
+  // clang-format off
+  return TransformMatrix2D({
+    v, 0, 0,
+    0, 1, 0,
+    0, 0, 1
+  });
+  // clang-format on
+}
+
+template <>
+TransformMatrix2D TransformMatrix2D::create<TransformOp::ScaleY>(double v) {
+  // clang-format off
+  return TransformMatrix2D({
+    1, 0, 0,
+    0, v, 0,
+    0, 0, 1
+  });
+  // clang-format on
+}
+
+template <>
+TransformMatrix2D TransformMatrix2D::create<TransformOp::TranslateX>(double v) {
+  // clang-format off
+  return TransformMatrix2D({
+    1, 0, 0,
+    0, 1, 0,
+    v, 0, 1
+  });
+  // clang-format on
+}
+
+template <>
+TransformMatrix2D TransformMatrix2D::create<TransformOp::TranslateY>(double v) {
+  // clang-format off
+  return TransformMatrix2D({
+    1, 0, 0,
+    0, 1, 0,
+    0, v, 1
+  });
+  // clang-format on
+}
+
+template <>
+TransformMatrix2D TransformMatrix2D::create<TransformOp::SkewX>(double v) {
+  const auto tanVal = std::tan(v);
+  // clang-format off
+  return TransformMatrix2D({
+        1, 0, 0,
+   tanVal, 1, 0,
+        0, 0, 1
+  });
+  // clang-format on
+}
+
+template <>
+TransformMatrix2D TransformMatrix2D::create<TransformOp::SkewY>(double v) {
+  const auto tanVal = std::tan(v);
+  // clang-format off
+  return TransformMatrix2D({
+    1, tanVal, 0,
+    0,      1, 0,
+    0,      0, 1
+  });
+  // clang-format on
+}
+
+template <TransformOp TOperation>
+TransformMatrix2D TransformMatrix2D::create(double value) {
+  throw std::invalid_argument(
+      "[Reanimated] Cannot create TransformMatrix2D from: " + getTransformOperationName(TOperation));
+}
+
+double TransformMatrix2D::determinant() const {
+  return (matrix_[0] * matrix_[4] * matrix_[8]) + (matrix_[1] * matrix_[5] * matrix_[6]) +
+      (matrix_[2] * matrix_[3] * matrix_[7]) - (matrix_[2] * matrix_[4] * matrix_[6]) -
+      (matrix_[1] * matrix_[3] * matrix_[8]) - (matrix_[0] * matrix_[5] * matrix_[7]);
+}
+
+void TransformMatrix2D::translate2d(const Vector2D &translation) {
+  for (size_t i = 0; i < 3; ++i) {
+    matrix_[6 + i] += translation[0] * matrix_[i] + translation[1] * matrix_[3 + i];
+  }
+}
+
+void TransformMatrix2D::scale2d(const Vector2D &scale) {
+  for (size_t i = 0; i < 3; ++i) {
+    matrix_[i] *= scale[0];
+    matrix_[3 + i] *= scale[1];
+  }
+}
+
+std::optional<TransformMatrix2D::Decomposed> TransformMatrix2D::decompose() const {
+  auto matrixCp = *this;
+
+  if (!matrixCp.normalize()) {
+    return std::nullopt;
+  }
+
+  const auto translation = matrixCp.getTranslation();
+
+  // Take the 2×2 linear part into two column vectors
+  std::array<Vector2D, 2> rows;
+  for (size_t i = 0; i < 2; ++i) {
+    rows[i] = Vector2D(matrixCp[i * 3], matrixCp[i * 3 + 1]);
+  }
+
+  auto [scale, skew] = computeScaleAndSkew(rows);
+
+  // At this point, the matrix (in rows) is orthonormal.
+  // Check for a coordinate system flip. If the determinant
+  // is negative, then negate the matrix and the scaling factors.
+  if (rows[0].cross(rows[1]) < 0) {
+    scale *= -1;
+    for (auto &row : rows) {
+      row *= -1;
+    }
+  }
+
+  const auto rotation = computeRotation(rows);
+
+  return TransformMatrix2D::Decomposed{.scale = scale, .skew = skew, .rotation = rotation, .translation = translation};
+}
+
+TransformMatrix2D TransformMatrix2D::recompose(const TransformMatrix2D::Decomposed &decomposed) {
+  auto result = TransformMatrix2D();
+
+  // Apply Translation
+  result.translate2d(decomposed.translation);
+
+  // Apply Rotation
+  if (decomposed.rotation != 0) {
+    const auto rotationMatrix = TransformMatrix2D::create<TransformOp::Rotate>(decomposed.rotation);
+    result = rotationMatrix * result;
+  }
+
+  // Apply XY shear
+  if (decomposed.skew != 0) {
+    auto tmp = TransformMatrix2D();
+    tmp[3] = decomposed.skew;
+    result = tmp * result;
+  }
+
+  // Apply Scale
+  result.scale2d(decomposed.scale);
+
+  return result;
+}
+
+Vector2D TransformMatrix2D::getTranslation() const {
+  return Vector2D(matrix_[6], matrix_[7]);
+}
+
+std::pair<Vector2D, double> TransformMatrix2D::computeScaleAndSkew(std::array<Vector2D, 2> &rows) {
+  Vector2D scale;
+
+  // Compute X scale and normalize first row
+  scale[0] = rows[0].length();
+  rows[0].normalize();
+
+  // Compute XY shear and orthogonalize second row against first
+  double skew = rows[0].dot(rows[1]);
+  rows[1] = rows[1].addScaled(rows[0], -skew);
+
+  // Now, compute Y scale and normalize second row
+  scale[1] = rows[1].length();
+  rows[1].normalize();
+
+  // Next, Normalize shear by Y scale
+  skew /= scale[1];
+
+  return {scale, skew};
+}
+
+double TransformMatrix2D::computeRotation(std::array<Vector2D, 2> &rows) {
+  // For 2D, we can compute rotation directly from the orthonormal matrix
+  // The rotation angle is atan2(m01, m00) where m01 is rows[0][1] and m00 is
+  // rows[0][0]
+  return std::atan2(rows[0][1], rows[0][0]);
+}
+// Explicit template instantiations for unsupported operations
+// These will use the fallback template function that throws an error
+template TransformMatrix2D TransformMatrix2D::create<TransformOp::Perspective>(double);
+template TransformMatrix2D TransformMatrix2D::create<TransformOp::RotateX>(double);
+template TransformMatrix2D TransformMatrix2D::create<TransformOp::RotateY>(double);
+template TransformMatrix2D TransformMatrix2D::create<TransformOp::RotateZ>(double);
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/common/transforms/TransformMatrix2D.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <reanimated/CSS/common/transforms/TransformMatrix.h>
+#include <reanimated/CSS/common/transforms/TransformOp.h>
+#include <reanimated/CSS/common/transforms/vectors.h>
+
+#include <folly/dynamic.h>
+#include <utility>
+
+namespace reanimated::css {
+
+static constexpr size_t MATRIX_2D_DIMENSION = 3; // 3x3 matrix
+
+class TransformMatrix2D : public TransformMatrixBase<TransformMatrix2D, MATRIX_2D_DIMENSION> {
+ public:
+  struct Decomposed {
+    Vector2D scale;
+    double skew;
+    double rotation;
+    Vector2D translation;
+
+#ifndef NDEBUG
+    friend std::ostream &operator<<(std::ostream &os, const Decomposed &decomposed);
+#endif // NDEBUG
+
+    Decomposed interpolate(double progress, const Decomposed &other) const;
+  };
+
+  using TransformMatrixBase<TransformMatrix2D, MATRIX_2D_DIMENSION>::TransformMatrixBase;
+
+  explicit TransformMatrix2D(jsi::Runtime &rt, const jsi::Value &value);
+  explicit TransformMatrix2D(const folly::dynamic &array);
+
+  static bool canConstruct(jsi::Runtime &rt, const jsi::Value &value);
+  static bool canConstruct(const folly::dynamic &array);
+
+  template <TransformOp TOperation>
+  static TransformMatrix2D create(double value);
+
+  double determinant() const override;
+  void translate2d(const Vector2D &translation);
+  void scale2d(const Vector2D &scale);
+
+  std::optional<Decomposed> decompose() const;
+  static TransformMatrix2D recompose(const Decomposed &decomposed);
+
+ private:
+  Vector2D getTranslation() const;
+  static std::pair<Vector2D, double> computeScaleAndSkew(std::array<Vector2D, 2> &rows);
+  static double computeRotation(std::array<Vector2D, 2> &rows);
+};
+
+} // namespace reanimated::css