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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <string>
+
+namespace reanimated::css {
+
+enum class TransformOp : uint8_t {
+  Perspective,
+  Rotate,
+  RotateX,
+  RotateY,
+  RotateZ,
+  Scale,
+  ScaleX,
+  ScaleY,
+  TranslateX,
+  TranslateY,
+  SkewX,
+  SkewY,
+  Matrix,
+};
+
+TransformOp getTransformOperationType(const std::string &property);
+std::string getTransformOperationName(const TransformOp type);
+
+} // namespace reanimated::css

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

@@ -0,0 +1,156 @@
+#include <reanimated/CSS/common/transforms/vectors.h>
+
+namespace reanimated::css {
+
+// Vector2D
+
+double &Vector2D::operator[](const size_t idx) {
+  return vec[idx];
+}
+
+const double &Vector2D::operator[](const size_t idx) const {
+  return vec[idx];
+}
+
+Vector2D &Vector2D::operator*=(const double scalar) {
+  vec[0] *= scalar;
+  vec[1] *= scalar;
+  return *this;
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const Vector2D &vector) {
+  os << "Vector2D(" << vector.vec[0] << ", " << vector.vec[1] << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+double Vector2D::length() const {
+  return std::hypot(vec[0], vec[1]);
+}
+
+void Vector2D::scaleToLength(double targetLength) {
+  double currentLength = length();
+  if (currentLength != 0) {
+    double factor = targetLength / currentLength;
+    vec[0] *= factor;
+    vec[1] *= factor;
+  }
+}
+
+void Vector2D::normalize() {
+  scaleToLength(1);
+}
+
+double Vector2D::dot(const Vector2D &other) const {
+  return vec[0] * other.vec[0] + vec[1] * other.vec[1];
+}
+
+double Vector2D::cross(const Vector2D &other) const {
+  return vec[0] * other.vec[1] - vec[1] * other.vec[0];
+}
+
+Vector2D Vector2D::addScaled(const Vector2D &other, const double scale) const {
+  return Vector2D{vec[0] + scale * other.vec[0], vec[1] + scale * other.vec[1]};
+}
+
+Vector2D Vector2D::interpolate(const double progress, const Vector2D &other) const {
+  return Vector2D{vec[0] + progress * (other.vec[0] - vec[0]), vec[1] + progress * (other.vec[1] - vec[1])};
+}
+
+// Vector3D
+
+double &Vector3D::operator[](const size_t idx) {
+  return vec[idx];
+}
+
+const double &Vector3D::operator[](const size_t idx) const {
+  return vec[idx];
+}
+
+Vector3D &Vector3D::operator*=(const double scalar) {
+  vec[0] *= scalar;
+  vec[1] *= scalar;
+  vec[2] *= scalar;
+  return *this;
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const Vector3D &vector) {
+  os << "Vector3D(" << vector.vec[0] << ", " << vector.vec[1] << ", " << vector.vec[2] << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+double Vector3D::length() const {
+  return std::hypot(vec[0], vec[1], vec[2]);
+}
+
+void Vector3D::scaleToLength(double targetLength) {
+  double currentLength = length();
+  if (currentLength != 0) {
+    double factor = targetLength / currentLength;
+    vec[0] *= factor;
+    vec[1] *= factor;
+    vec[2] *= factor;
+  }
+}
+
+void Vector3D::normalize() {
+  scaleToLength(1);
+}
+
+double Vector3D::dot(const Vector3D &other) const {
+  return vec[0] * other.vec[0] + vec[1] * other.vec[1] + vec[2] * other.vec[2];
+}
+
+Vector3D Vector3D::cross(const Vector3D &other) const {
+  return Vector3D{
+      vec[1] * other.vec[2] - vec[2] * other.vec[1],
+      vec[2] * other.vec[0] - vec[0] * other.vec[2],
+      vec[0] * other.vec[1] - vec[1] * other.vec[0]};
+}
+
+Vector3D Vector3D::addScaled(const Vector3D &other, const double scale) const {
+  return Vector3D{vec[0] + scale * other.vec[0], vec[1] + scale * other.vec[1], vec[2] + scale * other.vec[2]};
+}
+
+Vector3D Vector3D::interpolate(const double progress, const Vector3D &other) const {
+  return Vector3D{
+      vec[0] + progress * (other.vec[0] - vec[0]),
+      vec[1] + progress * (other.vec[1] - vec[1]),
+      vec[2] + progress * (other.vec[2] - vec[2])};
+}
+
+// Vector4D
+
+double &Vector4D::operator[](const size_t idx) {
+  return vec[idx];
+}
+
+const double &Vector4D::operator[](const size_t idx) const {
+  return vec[idx];
+}
+
+Vector4D Vector4D::interpolate(const double progress, const Vector4D &other) const {
+  return Vector4D{
+      vec[0] + progress * (other.vec[0] - vec[0]),
+      vec[1] + progress * (other.vec[1] - vec[1]),
+      vec[2] + progress * (other.vec[2] - vec[2]),
+      vec[3] + progress * (other.vec[3] - vec[3])};
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const Vector4D &vector) {
+  os << "Vector4D(" << vector.vec[0] << ", " << vector.vec[1] << ", " << vector.vec[2] << ", " << vector.vec[3] << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+} // namespace reanimated::css

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

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <array>
+
+#ifndef NDEBUG
+#include <iostream>
+#endif // NDEBUG
+
+namespace reanimated::css {
+
+struct Vector2D {
+  std::array<double, 2> vec;
+
+  Vector2D() : vec({0, 0}) {}
+  explicit Vector2D(double x, double y) : vec({x, y}) {}
+  explicit Vector2D(std::array<double, 2> vec) : vec(vec) {}
+
+  double &operator[](size_t idx);
+  const double &operator[](size_t idx) const;
+  Vector2D &operator*=(double scalar);
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const Vector2D &vector);
+#endif // NDEBUG
+
+  double length() const;
+  void scaleToLength(double targetLength);
+  void normalize();
+  double dot(const Vector2D &other) const;
+  double cross(const Vector2D &other) const;
+  Vector2D addScaled(const Vector2D &other, double scale) const;
+  Vector2D interpolate(double progress, const Vector2D &other) const;
+};
+
+struct Vector3D {
+  std::array<double, 3> vec;
+
+  Vector3D() : vec({0, 0, 0}) {}
+  explicit Vector3D(double x, double y, double z) : vec({x, y, z}) {}
+  explicit Vector3D(std::array<double, 3> vec) : vec(vec) {}
+
+  double &operator[](size_t idx);
+  const double &operator[](size_t idx) const;
+  Vector3D &operator*=(double scalar);
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const Vector3D &vector);
+#endif // NDEBUG
+
+  double length() const;
+  void scaleToLength(double targetLength);
+  void normalize();
+  double dot(const Vector3D &other) const;
+  Vector3D cross(const Vector3D &other) const;
+  Vector3D addScaled(const Vector3D &other, double scale) const;
+  Vector3D interpolate(double progress, const Vector3D &other) const;
+};
+
+struct Vector4D {
+  std::array<double, 4> vec;
+
+  Vector4D() : vec({0, 0, 0, 0}) {}
+  explicit Vector4D(double x, double y, double z, double w) : vec({x, y, z, w}) {}
+  explicit Vector4D(std::array<double, 4> vec) : vec(vec) {}
+
+  double &operator[](size_t idx);
+  const double &operator[](size_t idx) const;
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const Vector4D &vector);
+#endif // NDEBUG
+
+  Vector4D interpolate(double progress, const Vector4D &other) const;
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/common/values/CSSAngle.cpp

@@ -0,0 +1,93 @@
+#include <reanimated/CSS/common/values/CSSAngle.h>
+
+#include <iomanip>
+#include <regex>
+#include <string>
+#include <unordered_map>
+
+namespace reanimated::css {
+
+CSSAngle::CSSAngle() : value(0) {}
+
+CSSAngle::CSSAngle(const double value) : value(value) {}
+
+CSSAngle::CSSAngle(const std::string &rotationString) {
+  static const std::regex validNumberRegex(R"(^[-+]?\d*\.?\d+$)");
+  static const std::unordered_map<std::string, double> unitFactors = {
+      {"rad", 1},
+      {"deg", M_PI / 180},
+  };
+
+  // Find position of the first non-numeric character (first character
+  // of the unit, e.g. "deg" or "rad")
+  size_t pos = rotationString.find_first_not_of("0123456789.-+");
+
+  if (pos == std::string::npos) {
+    throw std::invalid_argument("[Reanimated] CSSAngle: Invalid angle value: " + rotationString);
+  }
+
+  std::string numericPart = rotationString.substr(0, pos);
+  std::string unitPart = rotationString.substr(pos);
+
+  if (!std::regex_match(numericPart, validNumberRegex)) {
+    throw std::invalid_argument("[Reanimated] CSSAngle: Invalid angle value: " + rotationString);
+  }
+
+  // Lookup the unit and convert to radians
+  auto it = unitFactors.find(unitPart);
+  if (it == unitFactors.cend()) {
+    throw std::invalid_argument("[Reanimated] CSSAngle: Invalid angle unit: " + unitPart);
+  }
+
+  double numericValue = std::stod(numericPart);
+
+  this->value = numericValue * it->second;
+}
+
+CSSAngle::CSSAngle(const char *cstr) : CSSAngle(std::string_view{cstr}) {}
+
+CSSAngle::CSSAngle(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  *this = CSSAngle(jsiValue.asString(rt).utf8(rt));
+}
+
+CSSAngle::CSSAngle(const folly::dynamic &value) {
+  *this = CSSAngle(value.asString().c_str());
+}
+
+bool CSSAngle::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  // TODO - improve canConstruct check and add check for string correctness
+  return jsiValue.isString() || jsiValue.isNumber();
+}
+
+bool CSSAngle::canConstruct(const folly::dynamic &value) {
+  return value.isString() || value.isNumber();
+}
+
+folly::dynamic CSSAngle::toDynamic() const {
+  return folly::dynamic(toString());
+}
+
+std::string CSSAngle::toString() const {
+  std::ostringstream stream;
+  stream << std::fixed << std::setprecision(4) << value;
+  return stream.str() + "rad";
+}
+
+CSSAngle CSSAngle::interpolate(double progress, const CSSAngle &to) const {
+  return CSSAngle(value + (to.value - value) * progress);
+}
+
+bool CSSAngle::operator==(const CSSAngle &other) const {
+  return value == other.value;
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const CSSAngle &angleValue) {
+  os << "CSSAngle(" << angleValue.value << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/common/values/CSSAngle.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSValue.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+struct CSSAngle : public CSSSimpleValue<CSSAngle> {
+  double value;
+
+  CSSAngle();
+  explicit CSSAngle(double value);
+  explicit CSSAngle(const std::string &rotationString);
+  explicit CSSAngle(const char *cstr);
+  explicit CSSAngle(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  explicit CSSAngle(const folly::dynamic &value);
+
+  static bool canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  static bool canConstruct(const folly::dynamic &value);
+
+  folly::dynamic toDynamic() const override;
+  std::string toString() const override;
+  CSSAngle interpolate(double progress, const CSSAngle &to) const override;
+
+  bool operator==(const CSSAngle &other) const;
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const CSSAngle &angleValue);
+#endif // NDEBUG
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/common/values/CSSBoolean.cpp

@@ -0,0 +1,48 @@
+#include <reanimated/CSS/common/values/CSSBoolean.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+CSSBoolean::CSSBoolean() : value(false) {}
+
+CSSBoolean::CSSBoolean(bool value) : value(value) {}
+
+CSSBoolean::CSSBoolean(jsi::Runtime &rt, const jsi::Value &jsiValue) : value(jsiValue.asBool()) {}
+
+CSSBoolean::CSSBoolean(const folly::dynamic &value) : value(value.asBool()) {}
+
+bool CSSBoolean::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  return jsiValue.isBool();
+}
+
+bool CSSBoolean::canConstruct(const folly::dynamic &value) {
+  return value.isBool();
+}
+
+folly::dynamic CSSBoolean::toDynamic() const {
+  return {value};
+}
+
+std::string CSSBoolean::toString() const {
+  return value ? "true" : "false";
+}
+
+CSSBoolean CSSBoolean::interpolate(double progress, const CSSBoolean &to) const {
+  return CSSBoolean(progress < 0.5 ? value : to.value);
+}
+
+bool CSSBoolean::operator==(const CSSBoolean &other) const {
+  return value == other.value;
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const CSSBoolean &boolValue) {
+  os << boolValue.toString();
+  return os;
+}
+
+#endif // NDEBUG
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/common/values/CSSBoolean.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSValue.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+struct CSSBoolean : public CSSSimpleValue<CSSBoolean> {
+  bool value;
+
+  CSSBoolean();
+  explicit CSSBoolean(bool value);
+  explicit CSSBoolean(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  explicit CSSBoolean(const folly::dynamic &value);
+
+  static bool canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  static bool canConstruct(const folly::dynamic &value);
+
+  folly::dynamic toDynamic() const override;
+  std::string toString() const override;
+  CSSBoolean interpolate(double progress, const CSSBoolean &to) const override;
+
+  bool operator==(const CSSBoolean &other) const;
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const CSSBoolean &boolValue);
+#endif // NDEBUG
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/common/values/CSSColor.cpp

@@ -0,0 +1,135 @@
+#include <reanimated/CSS/common/values/CSSColor.h>
+#include <reanimated/CSS/svg/values/SVGBrush.h>
+
+#include <utility>
+
+#include <string>
+
+namespace reanimated::css {
+
+// CSSColorBase template implementations
+
+template <ColorTypeEnum TColorType, typename TDerived>
+CSSColorBase<TColorType, TDerived>::CSSColorBase() : channels{0, 0, 0, 0}, colorType(TColorType::Transparent) {}
+
+template <ColorTypeEnum TColorType, typename TDerived>
+CSSColorBase<TColorType, TDerived>::CSSColorBase(TColorType colorType) : channels{0, 0, 0, 0}, colorType(colorType) {}
+
+template <ColorTypeEnum TColorType, typename TDerived>
+CSSColorBase<TColorType, TDerived>::CSSColorBase(int64_t numberValue)
+    : channels{0, 0, 0, 0}, colorType(TColorType::Rgba) {
+  uint32_t color;
+  // On Android, colors are represented as signed 32-bit integers. In JS, we use
+  // a bitwise operation (normalizedColor = normalizedColor | 0x0) to ensure the
+  // value is treated as a signed int, causing numbers above 2^31 to become
+  // negative. To correctly interpret these in C++, we cast negative values to
+  // int32_t to preserve their bit pattern, then assign to uint32_t. This wraps
+  // the bits (modulo 2^32), effectively reversing the JS-side bit shift.
+  if (numberValue < 0) {
+    color = static_cast<int32_t>(numberValue);
+  } else {
+    color = static_cast<uint32_t>(numberValue);
+  }
+  channels[0] = (color >> 16) & 0xFF; // Red
+  channels[1] = (color >> 8) & 0xFF; // Green
+  channels[2] = color & 0xFF; // Blue
+  channels[3] = (color >> 24) & 0xFF; // Alpha
+}
+
+template <ColorTypeEnum TColorType, typename TDerived>
+CSSColorBase<TColorType, TDerived>::CSSColorBase(bool value)
+    : channels{0, 0, 0, 0}, colorType(TColorType::Transparent) {}
+
+template <ColorTypeEnum TColorType, typename TDerived>
+CSSColorBase<TColorType, TDerived>::CSSColorBase(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a)
+    : channels{r, g, b, a}, colorType(TColorType::Rgba) {}
+
+template <ColorTypeEnum TColorType, typename TDerived>
+CSSColorBase<TColorType, TDerived>::CSSColorBase(ColorChannels colorChannels)
+    : channels{colorChannels}, colorType(TColorType::Rgba) {}
+
+template <ColorTypeEnum TColorType, typename TDerived>
+TDerived CSSColorBase<TColorType, TDerived>::interpolate(double progress, const TDerived &to) const {
+  ColorChannels fromChannels = channels;
+  ColorChannels toChannels = to.channels;
+
+  if (colorType == TColorType::Transparent) {
+    fromChannels = {toChannels[0], toChannels[1], toChannels[2], 0};
+  } else if (to.colorType == TColorType::Transparent) {
+    toChannels = {fromChannels[0], fromChannels[1], fromChannels[2], 0};
+  }
+
+  ColorChannels resultChannels;
+  for (size_t i = 0; i < 4; ++i) {
+    const auto &fromValue = fromChannels[i];
+    const auto &toValue = toChannels[i];
+    // Cast one of operands to double to avoid unsigned int subtraction overflow
+    // (when from > to)
+    const double interpolated = (static_cast<double>(toValue) - fromValue) * progress + fromValue;
+    resultChannels[i] = static_cast<uint8_t>(std::round(std::clamp(interpolated, 0.0, 255.0)));
+  }
+
+  return TDerived(resultChannels);
+}
+
+template <ColorTypeEnum TColorType, typename TDerived>
+bool CSSColorBase<TColorType, TDerived>::operator==(const TDerived &other) const {
+  return colorType == other.colorType && channels == other.channels;
+}
+
+// CSSColor implementations
+
+CSSColor::CSSColor(jsi::Runtime &rt, const jsi::Value &jsiValue)
+    : CSSColorBase<CSSColorType, CSSColor>(CSSColorType::Transparent) {
+  if (jsiValue.isBool()) {
+    *this = CSSColor(jsiValue.getBool());
+  } else if (jsiValue.isNumber()) {
+    *this = CSSColor(static_cast<int64_t>(jsiValue.getNumber()));
+  }
+}
+
+CSSColor::CSSColor(const folly::dynamic &value) : CSSColorBase<CSSColorType, CSSColor>(CSSColorType::Transparent) {
+  if (value.isBool()) {
+    *this = CSSColor(value.getBool());
+  } else if (value.isNumber()) {
+    *this = CSSColor(value.asInt());
+  }
+}
+
+bool CSSColor::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  return jsiValue.isNumber() || jsiValue.isBool();
+}
+
+bool CSSColor::canConstruct(const folly::dynamic &value) {
+  return value.isNumber() || value.isBool();
+}
+
+folly::dynamic CSSColor::toDynamic() const {
+  if (colorType == CSSColorType::Rgba) {
+    return (channels[3] << 24) | (channels[0] << 16) | (channels[1] << 8) | channels[2];
+  }
+  return 0;
+}
+
+std::string CSSColor::toString() const {
+  if (colorType == CSSColorType::Rgba) {
+    return "rgba(" + std::to_string(channels[0]) + "," + std::to_string(channels[1]) + "," +
+        std::to_string(channels[2]) + "," + std::to_string(channels[3]) + ")";
+  }
+  return "transparent";
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const CSSColor &colorValue) {
+  os << "CSSColor(" << colorValue.toString() << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+// Explicit template instantiation
+template struct CSSColorBase<CSSColorType, CSSColor>;
+template struct CSSColorBase<SVGBrushType, SVGBrush>;
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/common/values/CSSColor.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <reanimated/CSS/common/definitions.h>
+#include <reanimated/CSS/common/values/CSSValue.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+// Base class with common color value functionality
+
+template <typename T>
+concept ColorTypeEnum = std::is_enum_v<T> && requires {
+  T::Rgba;
+  T::Transparent;
+};
+
+template <ColorTypeEnum TColorType, typename TDerived>
+struct CSSColorBase : public CSSSimpleValue<TDerived> {
+  ColorChannels channels;
+  TColorType colorType;
+
+  CSSColorBase();
+  explicit CSSColorBase(TColorType colorType);
+  explicit CSSColorBase(int64_t numberValue);
+  explicit CSSColorBase(bool value);
+
+  explicit CSSColorBase(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
+  explicit CSSColorBase(ColorChannels colorChannels);
+
+  TDerived interpolate(double progress, const TDerived &to) const override;
+
+  bool operator==(const TDerived &other) const;
+};
+
+// Enum class for color type
+
+enum class CSSColorType : std::uint8_t {
+  Rgba,
+  Transparent,
+};
+
+struct CSSColor : public CSSColorBase<CSSColorType, CSSColor> {
+  using CSSColorBase<CSSColorType, CSSColor>::CSSColorBase;
+  using CSSColorBase<CSSColorType, CSSColor>::operator==;
+
+  explicit CSSColor(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  explicit CSSColor(const folly::dynamic &value);
+
+  static bool canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  static bool canConstruct(const folly::dynamic &value);
+
+  folly::dynamic toDynamic() const override;
+  std::string toString() const override;
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const CSSColor &colorValue);
+#endif // NDEBUG
+};
+
+} // namespace reanimated::css