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

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

@@ -1,94 +1,94 @@
-#include <reanimated/CSS/common/values/CSSAngle.h>
-
-#include <sstream>
-#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
+#include <reanimated/CSS/common/values/CSSAngle.h>
+
+#include <sstream>
+#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

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

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

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