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

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

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

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

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

@@ -1,100 +1,100 @@
-#include <reanimated/CSS/common/values/CSSDiscreteArray.h>
-
-#include <string>
-#include <vector>
-
-namespace reanimated::css {
-
-template <typename TValue>
-CSSDiscreteArray<TValue>::CSSDiscreteArray() : values() {}
-
-template <typename TValue>
-CSSDiscreteArray<TValue>::CSSDiscreteArray(const std::vector<TValue> &values) : values(values) {}
-
-template <typename TValue>
-CSSDiscreteArray<TValue>::CSSDiscreteArray(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-  const auto &array = jsiValue.asObject(rt).asArray(rt);
-  values.reserve(array.size(rt));
-
-  for (size_t i = 0; i < array.size(rt); i++) {
-    values.emplace_back(rt, array.getValueAtIndex(rt, i));
-  }
-}
-
-template <typename TValue>
-CSSDiscreteArray<TValue>::CSSDiscreteArray(const folly::dynamic &array) {
-  values.reserve(array.size());
-
-  for (size_t i = 0; i < array.size(); i++) {
-    values.emplace_back(array[i]);
-  }
-}
-
-template <typename TValue>
-bool CSSDiscreteArray<TValue>::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-  // TODO - maybe add better validation
-  return jsiValue.isObject() && jsiValue.asObject(rt).isArray(rt);
-}
-
-template <typename TValue>
-bool CSSDiscreteArray<TValue>::canConstruct(const folly::dynamic &value) {
-  return value.isArray();
-}
-
-template <typename TValue>
-folly::dynamic CSSDiscreteArray<TValue>::toDynamic() const {
-  folly::dynamic array = folly::dynamic::array;
-  for (const auto &value : values) {
-    array.push_back(value.toDynamic());
-  }
-  return array;
-}
-
-template <typename TValue>
-std::string CSSDiscreteArray<TValue>::toString() const {
-  std::stringstream ss;
-
-  ss << "{";
-  for (size_t i = 0; i < values.size(); i++) {
-    ss << values[i].toString();
-    if (i < values.size() - 1) {
-      ss << ", ";
-    }
-  }
-  ss << "}";
-
-  return ss.str();
-}
-
-template <typename TValue>
-CSSDiscreteArray<TValue> CSSDiscreteArray<TValue>::interpolate(double progress, const CSSDiscreteArray<TValue> &other)
-    const {
-  return CSSDiscreteArray<TValue>(progress < 0.5 ? values : other.values);
-}
-
-template <typename TValue>
-bool CSSDiscreteArray<TValue>::operator==(const CSSDiscreteArray<TValue> &other) const {
-  if (values.size() != other.values.size()) {
-    return false;
-  }
-  for (size_t i = 0; i < values.size(); i++) {
-    if (values[i] != other.values[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-#ifndef NDEBUG
-
-template <typename TValue>
-std::ostream &operator<<(std::ostream &os, const CSSDiscreteArray<TValue> &arrayValue) {
-  os << "CSSDiscreteArray(" << arrayValue.toString() << ")";
-  return os;
-}
-
-#endif // NDEBUG
-
-template struct CSSDiscreteArray<CSSKeyword>;
-
-} // namespace reanimated::css
+#include <reanimated/CSS/common/values/CSSDiscreteArray.h>
+
+#include <string>
+#include <vector>
+
+namespace reanimated::css {
+
+template <typename TValue>
+CSSDiscreteArray<TValue>::CSSDiscreteArray() : values() {}
+
+template <typename TValue>
+CSSDiscreteArray<TValue>::CSSDiscreteArray(const std::vector<TValue> &values) : values(values) {}
+
+template <typename TValue>
+CSSDiscreteArray<TValue>::CSSDiscreteArray(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  const auto &array = jsiValue.asObject(rt).asArray(rt);
+  values.reserve(array.size(rt));
+
+  for (size_t i = 0; i < array.size(rt); i++) {
+    values.emplace_back(rt, array.getValueAtIndex(rt, i));
+  }
+}
+
+template <typename TValue>
+CSSDiscreteArray<TValue>::CSSDiscreteArray(const folly::dynamic &array) {
+  values.reserve(array.size());
+
+  for (size_t i = 0; i < array.size(); i++) {
+    values.emplace_back(array[i]);
+  }
+}
+
+template <typename TValue>
+bool CSSDiscreteArray<TValue>::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  // TODO - maybe add better validation
+  return jsiValue.isObject() && jsiValue.asObject(rt).isArray(rt);
+}
+
+template <typename TValue>
+bool CSSDiscreteArray<TValue>::canConstruct(const folly::dynamic &value) {
+  return value.isArray();
+}
+
+template <typename TValue>
+folly::dynamic CSSDiscreteArray<TValue>::toDynamic() const {
+  folly::dynamic array = folly::dynamic::array;
+  for (const auto &value : values) {
+    array.push_back(value.toDynamic());
+  }
+  return array;
+}
+
+template <typename TValue>
+std::string CSSDiscreteArray<TValue>::toString() const {
+  std::stringstream ss;
+
+  ss << "{";
+  for (size_t i = 0; i < values.size(); i++) {
+    ss << values[i].toString();
+    if (i < values.size() - 1) {
+      ss << ", ";
+    }
+  }
+  ss << "}";
+
+  return ss.str();
+}
+
+template <typename TValue>
+CSSDiscreteArray<TValue> CSSDiscreteArray<TValue>::interpolate(double progress, const CSSDiscreteArray<TValue> &other)
+    const {
+  return CSSDiscreteArray<TValue>(progress < 0.5 ? values : other.values);
+}
+
+template <typename TValue>
+bool CSSDiscreteArray<TValue>::operator==(const CSSDiscreteArray<TValue> &other) const {
+  if (values.size() != other.values.size()) {
+    return false;
+  }
+  for (size_t i = 0; i < values.size(); i++) {
+    if (values[i] != other.values[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+#ifndef NDEBUG
+
+template <typename TValue>
+std::ostream &operator<<(std::ostream &os, const CSSDiscreteArray<TValue> &arrayValue) {
+  os << "CSSDiscreteArray(" << arrayValue.toString() << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+template struct CSSDiscreteArray<CSSKeyword>;
+
+} // namespace reanimated::css