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

@@ -1,38 +1,38 @@
-#pragma once
-
-#include <reanimated/CSS/common/values/CSSValue.h>
-
-#include <string>
-
-namespace reanimated::css {
-
-struct CSSLength : public CSSResolvableValue<CSSLength, double> {
-  double value;
-  bool isRelative;
-
-  CSSLength();
-  explicit CSSLength(double value);
-  explicit CSSLength(double value, bool isRelative);
-  explicit CSSLength(const char *value);
-  explicit CSSLength(jsi::Runtime &rt, const jsi::Value &jsiValue);
-  explicit CSSLength(const folly::dynamic &value);
-
-  static bool canConstruct(const std::string &value);
-  static bool canConstruct(const char *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;
-  CSSLength interpolate(double progress, const CSSLength &to, const ResolvableValueInterpolationContext &context)
-      const override;
-  std::optional<double> resolve(const ResolvableValueInterpolationContext &context) const override;
-
-  bool operator==(const CSSLength &other) const;
-
-#ifndef NDEBUG
-  friend std::ostream &operator<<(std::ostream &os, const CSSLength &dimension);
-#endif // NDEBUG
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSValue.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+struct CSSLength : public CSSResolvableValue<CSSLength, double> {
+  double value;
+  bool isRelative;
+
+  CSSLength();
+  explicit CSSLength(double value);
+  explicit CSSLength(double value, bool isRelative);
+  explicit CSSLength(const char *value);
+  explicit CSSLength(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  explicit CSSLength(const folly::dynamic &value);
+
+  static bool canConstruct(const std::string &value);
+  static bool canConstruct(const char *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;
+  CSSLength interpolate(double progress, const CSSLength &to, const ResolvableValueInterpolationContext &context)
+      const override;
+  std::optional<double> resolve(const ResolvableValueInterpolationContext &context) const override;
+
+  bool operator==(const CSSLength &other) const;
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const CSSLength &dimension);
+#endif // NDEBUG
+};
+
+} // namespace reanimated::css

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

@@ -1,82 +1,82 @@
-#include <reanimated/CSS/common/values/CSSNumber.h>
-
-#include <algorithm>
-#include <string>
-
-namespace reanimated::css {
-
-template <typename TDerived, typename TValue>
-CSSNumberBase<TDerived, TValue>::CSSNumberBase() : value(0) {}
-
-template <typename TDerived, typename TValue>
-CSSNumberBase<TDerived, TValue>::CSSNumberBase(TValue value) : value(value) {}
-
-template <typename TDerived, typename TValue>
-CSSNumberBase<TDerived, TValue>::CSSNumberBase(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-  value = static_cast<TValue>(jsiValue.asNumber());
-}
-
-template <typename TDerived, typename TValue>
-CSSNumberBase<TDerived, TValue>::CSSNumberBase(const folly::dynamic &value) {
-  this->value = static_cast<TValue>(value.asDouble());
-}
-
-template <typename TDerived, typename TValue>
-bool CSSNumberBase<TDerived, TValue>::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-  return jsiValue.isNumber();
-}
-
-template <typename TDerived, typename TValue>
-bool CSSNumberBase<TDerived, TValue>::canConstruct(const folly::dynamic &value) {
-  return value.isInt() || value.isDouble();
-}
-
-template <typename TDerived, typename TValue>
-folly::dynamic CSSNumberBase<TDerived, TValue>::toDynamic() const {
-  return value;
-}
-
-template <typename TDerived, typename TValue>
-std::string CSSNumberBase<TDerived, TValue>::toString() const {
-  return std::to_string(value);
-}
-
-template <typename TDerived, typename TValue>
-TDerived CSSNumberBase<TDerived, TValue>::interpolate(double progress, const TDerived &other) const {
-  return TDerived(value + progress * (other.value - value));
-}
-
-template <typename TDerived, typename TValue>
-bool CSSNumberBase<TDerived, TValue>::operator==(const CSSNumberBase<TDerived, TValue> &other) const {
-  return value == other.value;
-}
-
-CSSInteger CSSInteger::interpolate(double progress, const CSSInteger &other) const {
-  return CSSInteger(static_cast<int>(std::round(value + progress * (other.value - value))));
-}
-
-template struct CSSNumberBase<CSSDouble, double>;
-template struct CSSNumberBase<CSSInteger, int>;
-
-#ifdef ANDROID
-
-CSSShadowRadiusAndroid::CSSShadowRadiusAndroid() : CSSNumberBase<CSSShadowRadiusAndroid, double>(1.0) {}
-
-CSSShadowRadiusAndroid::CSSShadowRadiusAndroid(const double value)
-    : CSSNumberBase<CSSShadowRadiusAndroid, double>(std::max(1.0, value)) {}
-
-CSSShadowRadiusAndroid::CSSShadowRadiusAndroid(jsi::Runtime &rt, const jsi::Value &jsiValue)
-    : CSSNumberBase<CSSShadowRadiusAndroid, double>(rt, jsiValue) {
-  value = std::max(1.0, value);
-}
-
-CSSShadowRadiusAndroid::CSSShadowRadiusAndroid(const folly::dynamic &value)
-    : CSSNumberBase<CSSShadowRadiusAndroid, double>(value) {
-  this->value = std::max(1.0, value.getDouble());
-}
-
-template struct CSSNumberBase<CSSShadowRadiusAndroid, double>;
-
-#endif
-
-} // namespace reanimated::css
+#include <reanimated/CSS/common/values/CSSNumber.h>
+
+#include <algorithm>
+#include <string>
+
+namespace reanimated::css {
+
+template <typename TDerived, typename TValue>
+CSSNumberBase<TDerived, TValue>::CSSNumberBase() : value(0) {}
+
+template <typename TDerived, typename TValue>
+CSSNumberBase<TDerived, TValue>::CSSNumberBase(TValue value) : value(value) {}
+
+template <typename TDerived, typename TValue>
+CSSNumberBase<TDerived, TValue>::CSSNumberBase(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  value = static_cast<TValue>(jsiValue.asNumber());
+}
+
+template <typename TDerived, typename TValue>
+CSSNumberBase<TDerived, TValue>::CSSNumberBase(const folly::dynamic &value) {
+  this->value = static_cast<TValue>(value.asDouble());
+}
+
+template <typename TDerived, typename TValue>
+bool CSSNumberBase<TDerived, TValue>::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  return jsiValue.isNumber();
+}
+
+template <typename TDerived, typename TValue>
+bool CSSNumberBase<TDerived, TValue>::canConstruct(const folly::dynamic &value) {
+  return value.isInt() || value.isDouble();
+}
+
+template <typename TDerived, typename TValue>
+folly::dynamic CSSNumberBase<TDerived, TValue>::toDynamic() const {
+  return value;
+}
+
+template <typename TDerived, typename TValue>
+std::string CSSNumberBase<TDerived, TValue>::toString() const {
+  return std::to_string(value);
+}
+
+template <typename TDerived, typename TValue>
+TDerived CSSNumberBase<TDerived, TValue>::interpolate(double progress, const TDerived &other) const {
+  return TDerived(value + progress * (other.value - value));
+}
+
+template <typename TDerived, typename TValue>
+bool CSSNumberBase<TDerived, TValue>::operator==(const CSSNumberBase<TDerived, TValue> &other) const {
+  return value == other.value;
+}
+
+CSSInteger CSSInteger::interpolate(double progress, const CSSInteger &other) const {
+  return CSSInteger(static_cast<int>(std::round(value + progress * (other.value - value))));
+}
+
+template struct CSSNumberBase<CSSDouble, double>;
+template struct CSSNumberBase<CSSInteger, int>;
+
+#ifdef ANDROID
+
+CSSShadowRadiusAndroid::CSSShadowRadiusAndroid() : CSSNumberBase<CSSShadowRadiusAndroid, double>(1.0) {}
+
+CSSShadowRadiusAndroid::CSSShadowRadiusAndroid(const double value)
+    : CSSNumberBase<CSSShadowRadiusAndroid, double>(std::max(1.0, value)) {}
+
+CSSShadowRadiusAndroid::CSSShadowRadiusAndroid(jsi::Runtime &rt, const jsi::Value &jsiValue)
+    : CSSNumberBase<CSSShadowRadiusAndroid, double>(rt, jsiValue) {
+  value = std::max(1.0, value);
+}
+
+CSSShadowRadiusAndroid::CSSShadowRadiusAndroid(const folly::dynamic &value)
+    : CSSNumberBase<CSSShadowRadiusAndroid, double>(value) {
+  this->value = std::max(1.0, value.getDouble());
+}
+
+template struct CSSNumberBase<CSSShadowRadiusAndroid, double>;
+
+#endif
+
+} // namespace reanimated::css

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

@@ -1,63 +1,63 @@
-#pragma once
-
-#include <reanimated/CSS/common/values/CSSValue.h>
-
-#include <string>
-
-namespace reanimated::css {
-
-template <typename TDerived, typename TValue>
-struct CSSNumberBase : public CSSSimpleValue<TDerived> {
-  TValue value;
-
-  CSSNumberBase();
-  explicit CSSNumberBase(TValue value);
-  explicit CSSNumberBase(jsi::Runtime &rt, const jsi::Value &jsiValue);
-  explicit CSSNumberBase(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;
-  TDerived interpolate(double progress, const TDerived &other) const override;
-
-  bool operator==(const CSSNumberBase<TDerived, TValue> &other) const;
-};
-
-#ifndef NDEBUG
-
-template <typename TDerived, typename TValue>
-std::ostream &operator<<(std::ostream &os, const CSSNumberBase<TDerived, TValue> &numberValue) {
-  os << "CSSNumberBase(" << numberValue.toString() << ")";
-  return os;
-}
-
-#endif // NDEBUG
-
-struct CSSDouble : public CSSNumberBase<CSSDouble, double> {
-  // Inherit all constructors from the base class
-  using CSSNumberBase::CSSNumberBase;
-};
-struct CSSInteger : public CSSNumberBase<CSSInteger, int> {
-  // Inherit all constructors from the base class
-  using CSSNumberBase::CSSNumberBase;
-
-  CSSInteger interpolate(double progress, const CSSInteger &other) const override;
-};
-
-#ifdef ANDROID
-
-// For some reason Android crashes when blurRadius is smaller than 1 so we use a
-// custom value that will never be smaller than 1
-
-struct CSSShadowRadiusAndroid : public CSSNumberBase<CSSShadowRadiusAndroid, double> {
-  CSSShadowRadiusAndroid();
-  explicit CSSShadowRadiusAndroid(double value);
-  explicit CSSShadowRadiusAndroid(jsi::Runtime &rt, const jsi::Value &jsiValue);
-  explicit CSSShadowRadiusAndroid(const folly::dynamic &value);
-};
-
-#endif
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSValue.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+template <typename TDerived, typename TValue>
+struct CSSNumberBase : public CSSSimpleValue<TDerived> {
+  TValue value;
+
+  CSSNumberBase();
+  explicit CSSNumberBase(TValue value);
+  explicit CSSNumberBase(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  explicit CSSNumberBase(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;
+  TDerived interpolate(double progress, const TDerived &other) const override;
+
+  bool operator==(const CSSNumberBase<TDerived, TValue> &other) const;
+};
+
+#ifndef NDEBUG
+
+template <typename TDerived, typename TValue>
+std::ostream &operator<<(std::ostream &os, const CSSNumberBase<TDerived, TValue> &numberValue) {
+  os << "CSSNumberBase(" << numberValue.toString() << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+struct CSSDouble : public CSSNumberBase<CSSDouble, double> {
+  // Inherit all constructors from the base class
+  using CSSNumberBase::CSSNumberBase;
+};
+struct CSSInteger : public CSSNumberBase<CSSInteger, int> {
+  // Inherit all constructors from the base class
+  using CSSNumberBase::CSSNumberBase;
+
+  CSSInteger interpolate(double progress, const CSSInteger &other) const override;
+};
+
+#ifdef ANDROID
+
+// For some reason Android crashes when blurRadius is smaller than 1 so we use a
+// custom value that will never be smaller than 1
+
+struct CSSShadowRadiusAndroid : public CSSNumberBase<CSSShadowRadiusAndroid, double> {
+  CSSShadowRadiusAndroid();
+  explicit CSSShadowRadiusAndroid(double value);
+  explicit CSSShadowRadiusAndroid(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  explicit CSSShadowRadiusAndroid(const folly::dynamic &value);
+};
+
+#endif
+
+} // namespace reanimated::css

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

@@ -1,118 +1,118 @@
-#pragma once
-
-#include <reanimated/CSS/misc/ViewStylesRepository.h>
-
-#include <memory>
-#include <string>
-#include <type_traits>
-
-namespace reanimated::css {
-
-using namespace facebook;
-
-enum class RelativeTo : std::uint8_t {
-  Parent,
-  Self,
-};
-
-struct ValueInterpolationContext {
-  const std::shared_ptr<const ShadowNode> &node;
-  const double fallbackInterpolateThreshold;
-};
-
-struct ResolvableValueInterpolationContext {
-  const std::shared_ptr<const ShadowNode> &node;
-  const double fallbackInterpolateThreshold;
-  const std::shared_ptr<ViewStylesRepository> &viewStylesRepository;
-  const std::string &relativeProperty;
-  const RelativeTo relativeTo;
-};
-
-struct CSSValue {
-  // This field should be overridden in discrete value types
-  static constexpr bool is_discrete_value = false;
-
-  virtual ~CSSValue() = default;
-
-  virtual folly::dynamic toDynamic() const = 0;
-  virtual std::string toString() const = 0;
-};
-
-// Base for leaf values that can be interpolated without resolution
-template <typename TDerived>
-struct CSSSimpleValue : public CSSValue {
-  static constexpr bool is_resolvable_value = false;
-
-  virtual TDerived interpolate(double progress, const TDerived &to) const = 0;
-  virtual bool canInterpolateTo(const TDerived &to) const {
-    return true;
-  }
-};
-
-// Base for leaf values that need resolution before interpolation
-template <typename TDerived, typename TResolved = TDerived>
-struct CSSResolvableValue : public CSSValue {
-  static constexpr bool is_resolvable_value = true;
-
-  virtual TDerived interpolate(double progress, const TDerived &to, const ResolvableValueInterpolationContext &context)
-      const = 0;
-  virtual std::optional<TResolved> resolve(const ResolvableValueInterpolationContext &context) const = 0;
-  virtual bool canInterpolateTo(const TDerived &to) const {
-    return true;
-  }
-};
-
-// Checks if a type is a resolvable value that needs resolution before
-// interpolation
-//template <typename TCSSValue>
-//concept Resolvable = requires {
-//  { TCSSValue::is_resolvable_value } -> std::convertible_to<bool>;
-//  requires TCSSValue::is_resolvable_value == true;
-//};
-//TODO        
-namespace detail {
-    template <typename T>
-    auto test_resolvable(int) -> std::enable_if_t<
-        std::is_convertible_v<decltype(T::is_resolvable_value), bool> && 
-        T::is_resolvable_value == true,
-        std::true_type
-    >;
-    template <typename>
-    auto test_resolvable(...) -> std::false_type;
-}
-
-template <typename TCSSValue>
-constexpr bool Resolvable = decltype(detail::test_resolvable<TCSSValue>(0))::value;
-    
-    
-    
-// Checks if a type is a discrete value
-//template <typename TCSSValue>
-//concept Discrete = requires {
-//  { TCSSValue::is_discrete_value } -> std::convertible_to<bool>;
-//  requires TCSSValue::is_discrete_value == true;
-//};
-//TODO    
-namespace detail {
-    template <typename T>
-    auto test_discrete(int) -> std::enable_if_t<
-        std::is_convertible_v<decltype(T::is_discrete_value), bool> && 
-        T::is_discrete_value == true,
-        std::true_type
-    >;
-    template <typename>
-    auto test_discrete(...) -> std::false_type;
-}
-
-template <typename TCSSValue>
-constexpr bool Discrete = decltype(detail::test_discrete<TCSSValue>(0))::value;
-
-
-// Check if a type is derived from CSSValue
-//template <typename TCSSValue>
-//concept CSSValueDerived = std::is_base_of_v<CSSValue, TCSSValue>;
-//TODO        
-template<typename TCSSValue>
-constexpr bool CSSValueDerived = std::is_base_of_v<CSSValue, TCSSValue>;
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/misc/ViewStylesRepository.h>
+
+#include <memory>
+#include <string>
+#include <type_traits>
+
+namespace reanimated::css {
+
+using namespace facebook;
+
+enum class RelativeTo : std::uint8_t {
+  Parent,
+  Self,
+};
+
+struct ValueInterpolationContext {
+  const std::shared_ptr<const ShadowNode> &node;
+  const double fallbackInterpolateThreshold;
+};
+
+struct ResolvableValueInterpolationContext {
+  const std::shared_ptr<const ShadowNode> &node;
+  const double fallbackInterpolateThreshold;
+  const std::shared_ptr<ViewStylesRepository> &viewStylesRepository;
+  const std::string &relativeProperty;
+  const RelativeTo relativeTo;
+};
+
+struct CSSValue {
+  // This field should be overridden in discrete value types
+  static constexpr bool is_discrete_value = false;
+
+  virtual ~CSSValue() = default;
+
+  virtual folly::dynamic toDynamic() const = 0;
+  virtual std::string toString() const = 0;
+};
+
+// Base for leaf values that can be interpolated without resolution
+template <typename TDerived>
+struct CSSSimpleValue : public CSSValue {
+  static constexpr bool is_resolvable_value = false;
+
+  virtual TDerived interpolate(double progress, const TDerived &to) const = 0;
+  virtual bool canInterpolateTo(const TDerived &to) const {
+    return true;
+  }
+};
+
+// Base for leaf values that need resolution before interpolation
+template <typename TDerived, typename TResolved = TDerived>
+struct CSSResolvableValue : public CSSValue {
+  static constexpr bool is_resolvable_value = true;
+
+  virtual TDerived interpolate(double progress, const TDerived &to, const ResolvableValueInterpolationContext &context)
+      const = 0;
+  virtual std::optional<TResolved> resolve(const ResolvableValueInterpolationContext &context) const = 0;
+  virtual bool canInterpolateTo(const TDerived &to) const {
+    return true;
+  }
+};
+
+// Checks if a type is a resolvable value that needs resolution before
+// interpolation
+//template <typename TCSSValue>
+//concept Resolvable = requires {
+//  { TCSSValue::is_resolvable_value } -> std::convertible_to<bool>;
+//  requires TCSSValue::is_resolvable_value == true;
+//};
+//TODO        
+namespace detail {
+    template <typename T>
+    auto test_resolvable(int) -> std::enable_if_t<
+        std::is_convertible_v<decltype(T::is_resolvable_value), bool> && 
+        T::is_resolvable_value == true,
+        std::true_type
+    >;
+    template <typename>
+    auto test_resolvable(...) -> std::false_type;
+}
+
+template <typename TCSSValue>
+constexpr bool Resolvable = decltype(detail::test_resolvable<TCSSValue>(0))::value;
+    
+    
+    
+// Checks if a type is a discrete value
+//template <typename TCSSValue>
+//concept Discrete = requires {
+//  { TCSSValue::is_discrete_value } -> std::convertible_to<bool>;
+//  requires TCSSValue::is_discrete_value == true;
+//};
+//TODO    
+namespace detail {
+    template <typename T>
+    auto test_discrete(int) -> std::enable_if_t<
+        std::is_convertible_v<decltype(T::is_discrete_value), bool> && 
+        T::is_discrete_value == true,
+        std::true_type
+    >;
+    template <typename>
+    auto test_discrete(...) -> std::false_type;
+}
+
+template <typename TCSSValue>
+constexpr bool Discrete = decltype(detail::test_discrete<TCSSValue>(0))::value;
+
+
+// Check if a type is derived from CSSValue
+//template <typename TCSSValue>
+//concept CSSValueDerived = std::is_base_of_v<CSSValue, TCSSValue>;
+//TODO        
+template<typename TCSSValue>
+constexpr bool CSSValueDerived = std::is_base_of_v<CSSValue, TCSSValue>;
+
+} // namespace reanimated::css