react-native-reanimated 3.17.0-rc.0 → 4.0.0-beta.1

package/Common/cpp/reanimated/CSS/common/TransformMatrix.h

@@ -0,0 +1,106 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <reanimated/CSS/common/Quaternion.h>
+#include <reanimated/CSS/common/definitions.h>
+#include <reanimated/CSS/common/vectors.h>
+
+#include <folly/dynamic.h>
+#include <string>
+#include <utility>
+
+namespace reanimated {
+
+struct DecomposedTransformMatrix {
+  Vector3D scale;
+  Vector3D skew;
+  Quaternion quaternion;
+  Vector3D translation;
+  Vector4D perspective;
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(
+      std::ostream &os,
+      const DecomposedTransformMatrix &decomposed);
+#endif // NDEBUG
+
+  DecomposedTransformMatrix interpolate(
+      double progress,
+      const DecomposedTransformMatrix &other) const;
+};
+
+class TransformMatrix {
+ public:
+  explicit TransformMatrix(const Vec16Array &matrix);
+  explicit TransformMatrix(const Matrix4x4 &matrix);
+  explicit TransformMatrix(jsi::Runtime &rt, const jsi::Value &value);
+
+  static TransformMatrix Identity();
+  static TransformMatrix Perspective(double value);
+  static TransformMatrix RotateX(double value);
+  static TransformMatrix RotateY(double value);
+  static TransformMatrix RotateZ(double value);
+  static TransformMatrix Scale(double value);
+  static TransformMatrix ScaleX(double value);
+  static TransformMatrix ScaleY(double value);
+  static TransformMatrix TranslateX(double value);
+  static TransformMatrix TranslateY(double value);
+  static TransformMatrix SkewX(double value);
+  static TransformMatrix SkewY(double value);
+
+  std::array<double, 4> &operator[](size_t rowIdx);
+  const std::array<double, 4> &operator[](size_t rowIdx) const;
+  bool operator==(const TransformMatrix &other) const;
+  TransformMatrix operator*(const TransformMatrix &rhs) const;
+  TransformMatrix operator*=(const TransformMatrix &rhs);
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(
+      std::ostream &os,
+      const TransformMatrix &matrix);
+#endif // NDEBUG
+
+  std::string toString() const;
+  jsi::Value toJSIValue(jsi::Runtime &rt) const;
+  folly::dynamic toDynamic() const;
+
+  bool isSingular() const;
+  bool normalize();
+  double determinant() const;
+  void adjugate();
+  bool invert();
+  void transpose();
+  void translate3d(const Vector3D &translation);
+  void scale3d(const Vector3D &scale);
+
+  std::optional<DecomposedTransformMatrix> decompose() const;
+  static TransformMatrix recompose(const DecomposedTransformMatrix &decomposed);
+  static TransformMatrix fromQuaternion(const Quaternion &q);
+
+ private:
+  Matrix4x4 matrix_;
+
+  std::optional<Vector4D> computePerspective() const;
+
+  Vector3D getTranslation() const;
+  static std::pair<Vector3D, Vector3D> computeScaleAndSkew(
+      std::array<Vector3D, 3> &rows);
+  static Quaternion computeQuaternion(std::array<Vector3D, 3> &columns);
+
+  inline static double determinant3x3(
+      double a,
+      double b,
+      double c,
+      double d,
+      double e,
+      double f,
+      double g,
+      double h,
+      double i);
+};
+
+Vector4D operator*(const Vector4D &v, const TransformMatrix &m);
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/reanimated/CSS/common/definitions.h

@@ -0,0 +1,30 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace reanimated {
+
+using namespace facebook;
+
+using PropertyNames = std::vector<std::string>;
+using PropertyValues = std::unique_ptr<jsi::Value>;
+using PropertyPath = std::vector<std::string>;
+/**
+ * If nullopt - all style properties can trigger transition
+ * If empty vector - no style property can trigger transition
+ * Otherwise - only specified style properties can trigger transition
+ */
+using TransitionProperties = std::optional<PropertyNames>;
+
+using EasingFunction = std::function<double(double)>;
+using ColorChannels = std::array<uint8_t, 4>;
+using Vec16Array = std::array<double, 16>;
+using Matrix4x4 = std::array<std::array<double, 4>, 4>;
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/reanimated/CSS/common/values/CSSAngle.cpp

@@ -0,0 +1,95 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <reanimated/CSS/common/values/CSSAngle.h>
+
+namespace reanimated {
+
+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(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  if (!jsiValue.isString()) {
+    throw std::invalid_argument(
+        "[Reanimated] CSSAngle: Invalid value type: " +
+        stringifyJSIValue(rt, jsiValue));
+  }
+
+  std::string strValue = jsiValue.asString(rt).utf8(rt);
+  *this = CSSAngle(strValue);
+}
+
+bool CSSAngle::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  // TODO - improve canConstruct check and add check for string correctness
+  return jsiValue.isString();
+}
+
+jsi::Value CSSAngle::toJSIValue(jsi::Runtime &rt) const {
+  return jsi::String::createFromUtf8(rt, toString());
+}
+
+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
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/reanimated/CSS/common/values/CSSAngle.h

@@ -0,0 +1,42 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <reanimated/CSS/common/values/CSSValue.h>
+
+#include <worklets/Tools/JSISerializer.h>
+
+#include <iomanip>
+#include <regex>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+
+namespace reanimated {
+
+using namespace worklets;
+
+struct CSSAngle : public CSSBaseValue<CSSValueType::Angle, CSSAngle> {
+  double value;
+
+  CSSAngle();
+  explicit CSSAngle(double value);
+  explicit CSSAngle(const std::string &rotationString);
+  explicit CSSAngle(jsi::Runtime &rt, const jsi::Value &jsiValue);
+
+  static bool canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue);
+
+  jsi::Value toJSIValue(jsi::Runtime &rt) const override;
+  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
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/reanimated/CSS/common/values/CSSBoolean.cpp

@@ -0,0 +1,50 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <reanimated/CSS/common/values/CSSBoolean.h>
+
+namespace reanimated {
+
+CSSBoolean::CSSBoolean() : value(false) {}
+
+CSSBoolean::CSSBoolean(bool value) : value(value) {}
+
+CSSBoolean::CSSBoolean(jsi::Runtime &rt, const jsi::Value &jsiValue)
+    : value(jsiValue.asBool()) {}
+
+bool CSSBoolean::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  return jsiValue.isBool();
+}
+
+jsi::Value CSSBoolean::toJSIValue(jsi::Runtime &rt) const {
+  return {value};
+}
+
+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
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/reanimated/CSS/common/values/CSSBoolean.h

@@ -0,0 +1,39 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <reanimated/CSS/common/values/CSSValue.h>
+
+#include <worklets/Tools/JSISerializer.h>
+
+#include <string>
+
+namespace reanimated {
+
+using namespace worklets;
+
+struct CSSBoolean : public CSSBaseValue<CSSValueType::Boolean, CSSBoolean> {
+  bool value;
+
+  CSSBoolean();
+  explicit CSSBoolean(bool value);
+  explicit CSSBoolean(jsi::Runtime &rt, const jsi::Value &jsiValue);
+
+  static bool canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue);
+
+  jsi::Value toJSIValue(jsi::Runtime &rt) const override;
+  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
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/reanimated/CSS/common/values/CSSColor.cpp

@@ -0,0 +1,136 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <reanimated/CSS/common/values/CSSColor.h>
+
+namespace reanimated {
+
+CSSColor::CSSColor()
+    : channels{0, 0, 0, 0}, colorType(ColorType::Transparent) {}
+
+CSSColor::CSSColor(ColorType colorType)
+    : channels{0, 0, 0, 0}, colorType(colorType) {}
+
+CSSColor::CSSColor(const uint8_t r, const uint8_t g, const uint8_t b)
+    : channels{r, g, b, 255}, colorType(ColorType::Rgba) {}
+
+CSSColor::CSSColor(
+    const uint8_t r,
+    const uint8_t g,
+    const uint8_t b,
+    const uint8_t a)
+    : channels{r, g, b, a}, colorType(ColorType::Rgba) {}
+
+CSSColor::CSSColor(const ColorChannels &colorChannels)
+    : channels{colorChannels[0], colorChannels[1], colorChannels[2], colorChannels[3]},
+      colorType(ColorType::Rgba) {}
+
+CSSColor::CSSColor(jsi::Runtime &rt, const jsi::Value &jsiValue)
+    : channels{0, 0, 0, 0}, colorType(ColorType::Transparent) {
+  if (jsiValue.isNumber()) {
+#ifdef ANDROID
+    // Android uses signed 32-bit integers for colors
+    auto color = static_cast<int32_t>(jsiValue.asNumber());
+#else
+    // iOS uses unsigned 32-bit integers for colors
+    auto color = static_cast<unsigned>(jsiValue.asNumber());
+#endif
+    channels[0] = (color >> 16) & 0xFF; // Red
+    channels[1] = (color >> 8) & 0xFF; // Green
+    channels[2] = color & 0xFF; // Blue
+    channels[3] = (color >> 24) & 0xFF; // Alpha
+    colorType = ColorType::Rgba;
+  } else if (
+      jsiValue.isUndefined() ||
+      (jsiValue.isString() &&
+       jsiValue.getString(rt).utf8(rt) == "transparent")) {
+    colorType = ColorType::Transparent;
+  } else {
+    throw std::invalid_argument(
+        "[Reanimated] CSSColor: Invalid value type: " +
+        stringifyJSIValue(rt, jsiValue));
+  }
+}
+
+bool CSSColor::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  // TODO - improve canConstruct check and add check for string correctness
+  return jsiValue.isNumber() || jsiValue.isString();
+}
+
+jsi::Value CSSColor::toJSIValue(jsi::Runtime &rt) const {
+  if (colorType == ColorType::Transparent) {
+    return 0x00000000;
+  }
+  return {
+      (channels[3] << 24) | (channels[0] << 16) | (channels[1] << 8) |
+      channels[2]};
+}
+
+folly::dynamic CSSColor::toDynamic() const {
+  if (colorType == ColorType::Transparent) {
+    return 0x00000000;
+  }
+  return (channels[3] << 24) | (channels[0] << 16) | (channels[1] << 8) |
+      channels[2];
+}
+
+std::string CSSColor::toString() const {
+  if (colorType == ColorType::Rgba) {
+    return "rgba(" + std::to_string(channels[0]) + "," +
+        std::to_string(channels[1]) + "," + std::to_string(channels[2]) + "," +
+        std::to_string(channels[3]) + ")";
+  } else {
+    return "transparent";
+  }
+}
+
+CSSColor CSSColor::interpolate(const double progress, const CSSColor &to)
+    const {
+  if (to.colorType == ColorType::Transparent &&
+      colorType == ColorType::Transparent) {
+    return *this;
+  }
+
+  ColorChannels fromChannels = channels;
+  ColorChannels toChannels = to.channels;
+  if (colorType == ColorType::Transparent) {
+    fromChannels = {toChannels[0], toChannels[1], toChannels[2], 0};
+  } else if (to.colorType == ColorType::Transparent) {
+    toChannels = {fromChannels[0], fromChannels[1], fromChannels[2], 0};
+  }
+
+  ColorChannels resultChannels;
+  for (size_t i = 0; i < 4; ++i) {
+    resultChannels[i] =
+        interpolateChannel(fromChannels[i], toChannels[i], progress);
+  }
+
+  return CSSColor(resultChannels);
+}
+
+uint8_t CSSColor::interpolateChannel(
+    const uint8_t from,
+    const uint8_t to,
+    const double progress) {
+  // Cast one of operands to double to avoid unsigned int subtraction overflow
+  // (when from > to)
+  double interpolated = (static_cast<double>(to) - from) * progress + from;
+  return static_cast<uint8_t>(std::round(std::clamp(interpolated, 0.0, 255.0)));
+}
+
+bool CSSColor::operator==(const CSSColor &other) const {
+  return colorType == other.colorType && channels[0] == other.channels[0] &&
+      channels[1] == other.channels[1] && channels[2] == other.channels[2] &&
+      channels[3] == other.channels[3];
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const CSSColor &colorValue) {
+  os << "CSSColor(" << colorValue.toString() << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/reanimated/CSS/common/values/CSSColor.h

@@ -0,0 +1,53 @@
+#pragma once
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <reanimated/CSS/common/definitions.h>
+#include <reanimated/CSS/common/values/CSSValue.h>
+
+#include <worklets/Tools/JSISerializer.h>
+
+#include <string>
+
+namespace reanimated {
+
+using namespace worklets;
+
+enum class ColorType {
+  Rgba,
+  Transparent,
+};
+
+struct CSSColor : public CSSBaseValue<CSSValueType::Color, CSSColor> {
+  ColorChannels channels;
+  ColorType colorType;
+
+  static const CSSColor Transparent;
+
+  CSSColor();
+  explicit CSSColor(ColorType colorType);
+  explicit CSSColor(uint8_t r, uint8_t g, uint8_t b);
+  explicit CSSColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
+  explicit CSSColor(const ColorChannels &colorChannels);
+  explicit CSSColor(jsi::Runtime &rt, const jsi::Value &jsiValue);
+
+  static bool canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue);
+
+  jsi::Value toJSIValue(jsi::Runtime &rt) const override;
+  folly::dynamic toDynamic() const override;
+  std::string toString() const override;
+  CSSColor interpolate(double progress, const CSSColor &to) const override;
+
+  static uint8_t interpolateChannel(uint8_t from, uint8_t to, double progress);
+
+  bool operator==(const CSSColor &other) const;
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const CSSColor &colorValue);
+#endif // NDEBUG
+};
+
+inline const CSSColor CSSColor::Transparent(ColorType::Transparent);
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED

package/Common/cpp/reanimated/CSS/common/values/CSSDimension.cpp

@@ -0,0 +1,131 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#include <reanimated/CSS/common/values/CSSDimension.h>
+
+namespace reanimated {
+
+CSSDimension::CSSDimension() : value(0), isRelative(false) {}
+
+CSSDimension::CSSDimension(const double value)
+    : value(value), isRelative(false) {}
+
+CSSDimension::CSSDimension(const double value, const bool isRelative)
+    : value(value), isRelative(isRelative) {}
+
+CSSDimension::CSSDimension(const std::string &value) {
+  if (!canConstruct(value)) {
+    throw std::invalid_argument(
+        "[Reanimated] CSSDimension: Invalid value: " + value);
+  }
+
+  std::string str = value;
+  str.pop_back();
+  this->value = std::stod(str) / 100;
+  this->isRelative = true;
+}
+
+CSSDimension::CSSDimension(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  if (jsiValue.isNumber()) {
+    this->value = jsiValue.asNumber();
+    this->isRelative = false;
+  } else if (jsiValue.isString()) {
+    std::string strValue = jsiValue.asString(rt).utf8(rt);
+    *this = CSSDimension(strValue); // Delegate to the string constructor
+  } else {
+    throw std::runtime_error(
+        "[Reanimated] CSSDimension: Unsupported value type");
+  }
+}
+
+bool CSSDimension::canConstruct(const std::string &value) {
+  return !value.empty() && value.back() == '%';
+}
+
+bool CSSDimension::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  return jsiValue.isNumber() ||
+      (jsiValue.isString() && canConstruct(jsiValue.getString(rt).utf8(rt)));
+}
+
+jsi::Value CSSDimension::toJSIValue(jsi::Runtime &rt) const {
+  if (isRelative) {
+    return jsi::String::createFromUtf8(rt, std::to_string(value * 100) + "%");
+  }
+  return {value};
+}
+
+folly::dynamic CSSDimension::toDynamic() const {
+  if (isRelative) {
+    return std::to_string(value * 100) + "%";
+  }
+  return value;
+}
+
+std::string CSSDimension::toString() const {
+  if (isRelative) {
+    return std::to_string(value * 100) + "%";
+  }
+  return std::to_string(value);
+}
+
+CSSDimension CSSDimension::interpolate(
+    const double progress,
+    const CSSDimension &to,
+    const CSSResolvableValueInterpolationContext &context) const {
+  // If both value types are the same, we can interpolate without reading the
+  // relative value from the shadow node
+  // (also, when one of the values is 0, and the other is relative)
+  if ((isRelative == to.isRelative) || (isRelative && to.value == 0) ||
+      (to.isRelative && value == 0)) {
+    return CSSDimension(
+        value + (to.value - value) * progress, isRelative || to.isRelative);
+  }
+  // Otherwise, we need to read the relative value from the shadow node and
+  // interpolate values as numbers
+  const auto resolvedFrom = resolve(context);
+  const auto resolvedTo = to.resolve(context);
+
+  if (!resolvedFrom.has_value() || !resolvedTo.has_value()) {
+    return progress < 0.5 ? *this : to;
+  }
+  return CSSDimension(
+      resolvedFrom.value() +
+      (resolvedTo.value() - resolvedFrom.value()) * progress);
+}
+
+std::optional<double> CSSDimension::resolve(
+    const CSSResolvableValueInterpolationContext &context) const {
+  if (!isRelative) {
+    return value;
+  }
+
+  jsi::Value relativeValue;
+  if (context.relativeTo == RelativeTo::Self) {
+    relativeValue = context.viewStylesRepository->getNodeProp(
+        context.node, context.relativeProperty);
+  } else {
+    relativeValue = context.viewStylesRepository->getParentNodeProp(
+        context.node, context.relativeProperty);
+  }
+
+  if (!relativeValue.isNumber()) {
+    return std::nullopt;
+  }
+
+  return value * relativeValue.getNumber();
+}
+
+bool CSSDimension::operator==(const CSSDimension &other) const {
+  return value == other.value && isRelative == other.isRelative;
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const CSSDimension &dimension) {
+  os << "CSSDimension(" << dimension.toString() << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+} // namespace reanimated
+
+#endif // RCT_NEW_ARCH_ENABLED