@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/CSSValueVariant.cpp

@@ -1,174 +1,174 @@
-#include <reanimated/CSS/common/values/CSSAngle.h>
-#include <reanimated/CSS/common/values/CSSBoolean.h>
-#include <reanimated/CSS/common/values/CSSColor.h>
-#include <reanimated/CSS/common/values/CSSDiscreteArray.h>
-#include <reanimated/CSS/common/values/CSSKeyword.h>
-#include <reanimated/CSS/common/values/CSSLength.h>
-#include <reanimated/CSS/common/values/CSSNumber.h>
-#include <reanimated/CSS/common/values/CSSValueVariant.h>
-#include <reanimated/CSS/common/values/complex/CSSBoxShadow.h>
-#include <reanimated/CSS/svg/values/SVGBrush.h>
-#include <reanimated/CSS/svg/values/SVGLength.h>
-#include <reanimated/CSS/svg/values/SVGStrokeDashArray.h>
-
-#include <worklets/Tools/JSISerializer.h>
-
-#include <string>
-#include <utility>
-#include <vector>
-
-namespace reanimated::css {
-
-template <typename... AllowedTypes>
-CSSValueVariant<AllowedTypes...>::CSSValueVariant(std::variant<AllowedTypes...> &&storage)
-    : storage_(std::move(storage)) {}
-
-template <typename... AllowedTypes>
-CSSValueVariant<AllowedTypes...>::CSSValueVariant(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-  auto tryOne = [&]<typename TCSSValue>() -> bool {
-    // We have to check in a runtime if the type can be constructed from the
-    // provided jsi::Value. The first match will be used to construct the
-    // CSS value.
-    if (!TCSSValue::canConstruct(rt, jsiValue)) {
-      return false;
-    }
-    storage_ = TCSSValue(rt, jsiValue);
-    return true;
-  };
-
-  // Try constructing with each allowed type until one succeeds
-  if (!(tryOne.template operator()<AllowedTypes>() || ...)) {
-    throw std::runtime_error(
-        "[Reanimated] No compatible type found for construction from: " + worklets::stringifyJSIValue(rt, jsiValue));
-  }
-}
-
-template <typename... AllowedTypes>
-CSSValueVariant<AllowedTypes...>::CSSValueVariant(const folly::dynamic &value) {
-  auto tryOne = [&]<typename TCSSValue>() -> bool {
-    // We have to check in a runtime if the type can be constructed from the
-    // provided folly::dynamic. The first match will be used to construct the
-    // CSS value.
-    if (!TCSSValue::canConstruct(value)) {
-      return false;
-    }
-    storage_ = TCSSValue(value);
-    return true;
-  };
-
-  // Try constructing with each allowed type until one succeeds
-  if (!(tryOne.template operator()<AllowedTypes>() || ...)) {
-    throw std::runtime_error("[Reanimated] No compatible type found for construction from: " + folly::toJson(value));
-  }
-}
-
-template <typename... AllowedTypes>
-bool CSSValueVariant<AllowedTypes...>::operator==(const CSSValueVariant &other) const {
-  if (storage_.index() != other.storage_.index()) {
-    return false;
-  }
-
-  return std::visit(
-      [](const auto &lhs, const auto &rhs) {
-        REA_IF_SAME_TYPE(lhs, rhs) {
-          return lhs == rhs;
-        }
-        return false;
-      },
-      storage_,
-      other.storage_);
-}
-
-template <typename... AllowedTypes>
-bool CSSValueVariant<AllowedTypes...>::operator==(const CSSValue &other) const {
-  if (auto *o = dynamic_cast<const CSSValueVariant *>(&other)) {
-    return *this == *o;
-  }
-  return false;
-}
-
-template <typename... AllowedTypes>
-folly::dynamic CSSValueVariant<AllowedTypes...>::toDynamic() const {
-  return std::visit([](const auto &v) { return v.toDynamic(); }, storage_);
-}
-
-template <typename... AllowedTypes>
-std::string CSSValueVariant<AllowedTypes...>::toString() const {
-  return std::visit([](const auto &v) { return v.toString(); }, storage_);
-}
-
-template <typename... AllowedTypes>
-CSSValueVariant<AllowedTypes...> CSSValueVariant<AllowedTypes...>::interpolate(
-    const double progress,
-    const CSSValueVariant &to,
-    const ValueInterpolationContext &context) const {
-  if (storage_.index() != to.storage_.index()) {
-    return fallbackInterpolate(progress, to, context.fallbackInterpolateThreshold);
-  }
-
-  return std::visit(
-      [&](const auto &fromValue, const auto &toValue) -> CSSValueVariant {
-        REA_IF_SAME_TYPE(fromValue, toValue) {
-          if constexpr (Resolvable<L>) {
-            throw std::runtime_error("[Reanimated] Resolvable value cannot be interpolated as non-resolvable");
-          } else if (fromValue.canInterpolateTo(toValue)) {
-            return CSSValueVariant(fromValue.interpolate(progress, toValue));
-          }
-        }
-        return fallbackInterpolate(progress, to, context.fallbackInterpolateThreshold);
-      },
-      storage_,
-      to.storage_);
-}
-
-template <typename... AllowedTypes>
-CSSValueVariant<AllowedTypes...> CSSValueVariant<AllowedTypes...>::interpolate(
-    const double progress,
-    const CSSValueVariant &to,
-    const ResolvableValueInterpolationContext &context) const {
-  if (storage_.index() != to.storage_.index()) {
-    return fallbackInterpolate(progress, to, context.fallbackInterpolateThreshold);
-  }
-
-  return std::visit(
-      [&](const auto &fromValue, const auto &toValue) -> CSSValueVariant {
-        REA_IF_SAME_TYPE(fromValue, toValue) {
-          if constexpr (!Resolvable<L>) {
-            throw std::runtime_error("[Reanimated] Non-resolvable value cannot be interpolated as resolvable");
-          } else if (fromValue.canInterpolateTo(toValue)) {
-            return CSSValueVariant(fromValue.interpolate(progress, toValue, context));
-          }
-        }
-        return fallbackInterpolate(progress, to, context.fallbackInterpolateThreshold);
-      },
-      storage_,
-      to.storage_);
-}
-
-template <typename... AllowedTypes>
-CSSValueVariant<AllowedTypes...> CSSValueVariant<AllowedTypes...>::fallbackInterpolate(
-    const double progress,
-    const CSSValueVariant &to,
-    const double fallbackInterpolateThreshold) const {
-  return (progress < fallbackInterpolateThreshold) ? *this : to;
-}
-
-template class CSSValueVariant<CSSLength>;
-template class CSSValueVariant<CSSLength, CSSKeyword>;
-template class CSSValueVariant<CSSDouble>;
-template class CSSValueVariant<CSSDouble, CSSKeyword>;
-template class CSSValueVariant<CSSInteger>;
-template class CSSValueVariant<CSSKeyword>;
-template class CSSValueVariant<CSSAngle>;
-template class CSSValueVariant<CSSBoolean>;
-template class CSSValueVariant<CSSColor>;
-template class CSSValueVariant<CSSDisplay>;
-template class CSSValueVariant<CSSBoxShadow>;
-template class CSSValueVariant<CSSDiscreteArray<CSSKeyword>>;
-
-template class CSSValueVariant<SVGLength>;
-template class CSSValueVariant<SVGLength, CSSKeyword>;
-template class CSSValueVariant<SVGStrokeDashArray, CSSKeyword>;
-template class CSSValueVariant<SVGBrush>;
-
-} // namespace reanimated::css
+#include <reanimated/CSS/common/values/CSSAngle.h>
+#include <reanimated/CSS/common/values/CSSBoolean.h>
+#include <reanimated/CSS/common/values/CSSColor.h>
+#include <reanimated/CSS/common/values/CSSDiscreteArray.h>
+#include <reanimated/CSS/common/values/CSSKeyword.h>
+#include <reanimated/CSS/common/values/CSSLength.h>
+#include <reanimated/CSS/common/values/CSSNumber.h>
+#include <reanimated/CSS/common/values/CSSValueVariant.h>
+#include <reanimated/CSS/common/values/complex/CSSBoxShadow.h>
+#include <reanimated/CSS/svg/values/SVGBrush.h>
+#include <reanimated/CSS/svg/values/SVGLength.h>
+#include <reanimated/CSS/svg/values/SVGStrokeDashArray.h>
+
+#include <worklets/Tools/JSISerializer.h>
+
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace reanimated::css {
+
+template <typename... AllowedTypes>
+CSSValueVariant<AllowedTypes...>::CSSValueVariant(std::variant<AllowedTypes...> &&storage)
+    : storage_(std::move(storage)) {}
+
+template <typename... AllowedTypes>
+CSSValueVariant<AllowedTypes...>::CSSValueVariant(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  auto tryOne = [&]<typename TCSSValue>() -> bool {
+    // We have to check in a runtime if the type can be constructed from the
+    // provided jsi::Value. The first match will be used to construct the
+    // CSS value.
+    if (!TCSSValue::canConstruct(rt, jsiValue)) {
+      return false;
+    }
+    storage_ = TCSSValue(rt, jsiValue);
+    return true;
+  };
+
+  // Try constructing with each allowed type until one succeeds
+  if (!(tryOne.template operator()<AllowedTypes>() || ...)) {
+    throw std::runtime_error(
+        "[Reanimated] No compatible type found for construction from: " + worklets::stringifyJSIValue(rt, jsiValue));
+  }
+}
+
+template <typename... AllowedTypes>
+CSSValueVariant<AllowedTypes...>::CSSValueVariant(const folly::dynamic &value) {
+  auto tryOne = [&]<typename TCSSValue>() -> bool {
+    // We have to check in a runtime if the type can be constructed from the
+    // provided folly::dynamic. The first match will be used to construct the
+    // CSS value.
+    if (!TCSSValue::canConstruct(value)) {
+      return false;
+    }
+    storage_ = TCSSValue(value);
+    return true;
+  };
+
+  // Try constructing with each allowed type until one succeeds
+  if (!(tryOne.template operator()<AllowedTypes>() || ...)) {
+    throw std::runtime_error("[Reanimated] No compatible type found for construction from: " + folly::toJson(value));
+  }
+}
+
+template <typename... AllowedTypes>
+bool CSSValueVariant<AllowedTypes...>::operator==(const CSSValueVariant &other) const {
+  if (storage_.index() != other.storage_.index()) {
+    return false;
+  }
+
+  return std::visit(
+      [](const auto &lhs, const auto &rhs) {
+        REA_IF_SAME_TYPE(lhs, rhs) {
+          return lhs == rhs;
+        }
+        return false;
+      },
+      storage_,
+      other.storage_);
+}
+
+template <typename... AllowedTypes>
+bool CSSValueVariant<AllowedTypes...>::operator==(const CSSValue &other) const {
+  if (auto *o = dynamic_cast<const CSSValueVariant *>(&other)) {
+    return *this == *o;
+  }
+  return false;
+}
+
+template <typename... AllowedTypes>
+folly::dynamic CSSValueVariant<AllowedTypes...>::toDynamic() const {
+  return std::visit([](const auto &v) { return v.toDynamic(); }, storage_);
+}
+
+template <typename... AllowedTypes>
+std::string CSSValueVariant<AllowedTypes...>::toString() const {
+  return std::visit([](const auto &v) { return v.toString(); }, storage_);
+}
+
+template <typename... AllowedTypes>
+CSSValueVariant<AllowedTypes...> CSSValueVariant<AllowedTypes...>::interpolate(
+    const double progress,
+    const CSSValueVariant &to,
+    const ValueInterpolationContext &context) const {
+  if (storage_.index() != to.storage_.index()) {
+    return fallbackInterpolate(progress, to, context.fallbackInterpolateThreshold);
+  }
+
+  return std::visit(
+      [&](const auto &fromValue, const auto &toValue) -> CSSValueVariant {
+        REA_IF_SAME_TYPE(fromValue, toValue) {
+          if constexpr (Resolvable<L>) {
+            throw std::runtime_error("[Reanimated] Resolvable value cannot be interpolated as non-resolvable");
+          } else if (fromValue.canInterpolateTo(toValue)) {
+            return CSSValueVariant(fromValue.interpolate(progress, toValue));
+          }
+        }
+        return fallbackInterpolate(progress, to, context.fallbackInterpolateThreshold);
+      },
+      storage_,
+      to.storage_);
+}
+
+template <typename... AllowedTypes>
+CSSValueVariant<AllowedTypes...> CSSValueVariant<AllowedTypes...>::interpolate(
+    const double progress,
+    const CSSValueVariant &to,
+    const ResolvableValueInterpolationContext &context) const {
+  if (storage_.index() != to.storage_.index()) {
+    return fallbackInterpolate(progress, to, context.fallbackInterpolateThreshold);
+  }
+
+  return std::visit(
+      [&](const auto &fromValue, const auto &toValue) -> CSSValueVariant {
+        REA_IF_SAME_TYPE(fromValue, toValue) {
+          if constexpr (!Resolvable<L>) {
+            throw std::runtime_error("[Reanimated] Non-resolvable value cannot be interpolated as resolvable");
+          } else if (fromValue.canInterpolateTo(toValue)) {
+            return CSSValueVariant(fromValue.interpolate(progress, toValue, context));
+          }
+        }
+        return fallbackInterpolate(progress, to, context.fallbackInterpolateThreshold);
+      },
+      storage_,
+      to.storage_);
+}
+
+template <typename... AllowedTypes>
+CSSValueVariant<AllowedTypes...> CSSValueVariant<AllowedTypes...>::fallbackInterpolate(
+    const double progress,
+    const CSSValueVariant &to,
+    const double fallbackInterpolateThreshold) const {
+  return (progress < fallbackInterpolateThreshold) ? *this : to;
+}
+
+template class CSSValueVariant<CSSLength>;
+template class CSSValueVariant<CSSLength, CSSKeyword>;
+template class CSSValueVariant<CSSDouble>;
+template class CSSValueVariant<CSSDouble, CSSKeyword>;
+template class CSSValueVariant<CSSInteger>;
+template class CSSValueVariant<CSSKeyword>;
+template class CSSValueVariant<CSSAngle>;
+template class CSSValueVariant<CSSBoolean>;
+template class CSSValueVariant<CSSColor>;
+template class CSSValueVariant<CSSDisplay>;
+template class CSSValueVariant<CSSBoxShadow>;
+template class CSSValueVariant<CSSDiscreteArray<CSSKeyword>>;
+
+template class CSSValueVariant<SVGLength>;
+template class CSSValueVariant<SVGLength, CSSKeyword>;
+template class CSSValueVariant<SVGStrokeDashArray, CSSKeyword>;
+template class CSSValueVariant<SVGBrush>;
+
+} // namespace reanimated::css

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

@@ -1,111 +1,111 @@
-#pragma once
-
-#include <reanimated/CSS/common/values/CSSValue.h>
-
-#include <folly/json.h>
-
-#include <stdexcept>
-#include <string>
-#include <type_traits>
-#include <utility>
-#include <variant>
-
-namespace reanimated::css {
-
-/**
- * Macro to check if two lambda parameters have the same reference-removed type.
- *
- * Usage:
- *   REA_IF_SAME_TYPE(lhs, rhs) {
- *     // same-type block
- *   } else {
- *     // mismatch block
- *   }
- */
-#define REA_IF_SAME_TYPE(lhs, rhs) \
-  using L = std::remove_reference_t<decltype(lhs)>; \
-  using R = std::remove_reference_t<decltype(rhs)>; \
-  if constexpr (std::is_same_v<L, R>) // NOLINT(readability/braces)
-
-// Checks whether a type has canConstruct(...) for a generic value
-template <typename TCSSValue, typename TValue>
-concept ValueConstructibleCSSValue = requires(TValue &&value) {
-  { TCSSValue::canConstruct(std::forward<TValue>(value)) } -> std::same_as<bool>;
-}; // NOLINT(readability/braces)
-
-// Checks whether a type can be constructed from a jsi::Value
-template <typename TCSSValue>
-concept JSIConstructibleCSSValue = requires(jsi::Runtime &rt, const jsi::Value &value) {
-  { TCSSValue::canConstruct(rt, value) } -> std::same_as<bool>;
-  { TCSSValue(rt, value) } -> std::same_as<TCSSValue>;
-}; // NOLINT(readability/braces)
-
-// Checks whether a type can be constructed from a folly::dynamic
-template <typename TCSSValue>
-concept DynamicConstructibleCSSValue = requires(const folly::dynamic &value) {
-  { TCSSValue::canConstruct(value) } -> std::same_as<bool>;
-  { TCSSValue(value) } -> std::same_as<TCSSValue>;
-}; // NOLINT(readability/braces)
-
-/**
- * CSSValueVariant
- *
- * A std::variant-based container for multiple CSSValue-derived types.
- */
-template <typename... AllowedTypes>
-class CSSValueVariant final : public CSSValue {
-  static_assert(
-      (JSIConstructibleCSSValue<AllowedTypes> && ...),
-      "CSSValueVariant accepts only types that can be constructed from a jsi::Value");
-  static_assert(
-      (DynamicConstructibleCSSValue<AllowedTypes> && ...),
-      "CSSValueVariant accepts only types that can be constructed from a folly::dynamic");
-
- public:
-  CSSValueVariant() = default;
-
-  /**
-   * Construct from std::variant storage directly
-   */
-  explicit CSSValueVariant(std::variant<AllowedTypes...> &&storage);
-
-  /**
-   * Construct from jsi::Value if it matches any AllowedType's constructor
-   * (chooses the first one that matches)
-   */
-  explicit CSSValueVariant(jsi::Runtime &rt, const jsi::Value &jsiValue);
-
-  /**
-   * Construct from folly::dynamic if it matches any AllowedType's constructor
-   * (chooses the first one that matches)
-   */
-  explicit CSSValueVariant(const folly::dynamic &value);
-
-  bool operator==(const CSSValueVariant &other) const;
-  bool operator==(const CSSValue &other) const;
-
-  folly::dynamic toDynamic() const override;
-  std::string toString() const override;
-
-  /**
-   * Interpolate (non-resolvable)
-   */
-  CSSValueVariant
-  interpolate(const double progress, const CSSValueVariant &to, const ValueInterpolationContext &context) const;
-
-  /**
-   * Interpolate (resolvable)
-   */
-  CSSValueVariant interpolate(
-      const double progress,
-      const CSSValueVariant &to,
-      const ResolvableValueInterpolationContext &context) const;
-
- private:
-  std::variant<AllowedTypes...> storage_;
-
-  CSSValueVariant
-  fallbackInterpolate(const double progress, const CSSValueVariant &to, double fallbackInterpolateThreshold) const;
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSValue.h>
+
+#include <folly/json.h>
+
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <variant>
+
+namespace reanimated::css {
+
+/**
+ * Macro to check if two lambda parameters have the same reference-removed type.
+ *
+ * Usage:
+ *   REA_IF_SAME_TYPE(lhs, rhs) {
+ *     // same-type block
+ *   } else {
+ *     // mismatch block
+ *   }
+ */
+#define REA_IF_SAME_TYPE(lhs, rhs) \
+  using L = std::remove_reference_t<decltype(lhs)>; \
+  using R = std::remove_reference_t<decltype(rhs)>; \
+  if constexpr (std::is_same_v<L, R>) // NOLINT(readability/braces)
+
+// Checks whether a type has canConstruct(...) for a generic value
+template <typename TCSSValue, typename TValue>
+concept ValueConstructibleCSSValue = requires(TValue &&value) {
+  { TCSSValue::canConstruct(std::forward<TValue>(value)) } -> std::same_as<bool>;
+}; // NOLINT(readability/braces)
+
+// Checks whether a type can be constructed from a jsi::Value
+template <typename TCSSValue>
+concept JSIConstructibleCSSValue = requires(jsi::Runtime &rt, const jsi::Value &value) {
+  { TCSSValue::canConstruct(rt, value) } -> std::same_as<bool>;
+  { TCSSValue(rt, value) } -> std::same_as<TCSSValue>;
+}; // NOLINT(readability/braces)
+
+// Checks whether a type can be constructed from a folly::dynamic
+template <typename TCSSValue>
+concept DynamicConstructibleCSSValue = requires(const folly::dynamic &value) {
+  { TCSSValue::canConstruct(value) } -> std::same_as<bool>;
+  { TCSSValue(value) } -> std::same_as<TCSSValue>;
+}; // NOLINT(readability/braces)
+
+/**
+ * CSSValueVariant
+ *
+ * A std::variant-based container for multiple CSSValue-derived types.
+ */
+template <typename... AllowedTypes>
+class CSSValueVariant final : public CSSValue {
+  static_assert(
+      (JSIConstructibleCSSValue<AllowedTypes> && ...),
+      "CSSValueVariant accepts only types that can be constructed from a jsi::Value");
+  static_assert(
+      (DynamicConstructibleCSSValue<AllowedTypes> && ...),
+      "CSSValueVariant accepts only types that can be constructed from a folly::dynamic");
+
+ public:
+  CSSValueVariant() = default;
+
+  /**
+   * Construct from std::variant storage directly
+   */
+  explicit CSSValueVariant(std::variant<AllowedTypes...> &&storage);
+
+  /**
+   * Construct from jsi::Value if it matches any AllowedType's constructor
+   * (chooses the first one that matches)
+   */
+  explicit CSSValueVariant(jsi::Runtime &rt, const jsi::Value &jsiValue);
+
+  /**
+   * Construct from folly::dynamic if it matches any AllowedType's constructor
+   * (chooses the first one that matches)
+   */
+  explicit CSSValueVariant(const folly::dynamic &value);
+
+  bool operator==(const CSSValueVariant &other) const;
+  bool operator==(const CSSValue &other) const;
+
+  folly::dynamic toDynamic() const override;
+  std::string toString() const override;
+
+  /**
+   * Interpolate (non-resolvable)
+   */
+  CSSValueVariant
+  interpolate(const double progress, const CSSValueVariant &to, const ValueInterpolationContext &context) const;
+
+  /**
+   * Interpolate (resolvable)
+   */
+  CSSValueVariant interpolate(
+      const double progress,
+      const CSSValueVariant &to,
+      const ResolvableValueInterpolationContext &context) const;
+
+ private:
+  std::variant<AllowedTypes...> storage_;
+
+  CSSValueVariant
+  fallbackInterpolate(const double progress, const CSSValueVariant &to, double fallbackInterpolateThreshold) const;
+};
+
+} // namespace reanimated::css