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

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

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