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

@@ -1,44 +1,45 @@
-#pragma once
-
-#include <reanimated/CSS/common/values/CSSKeyword.h>
-
-#include <string>
-#include <vector>
-#include <worklets/Tools/JSISerializer.h>
-#include <type_traits> 
-
-namespace reanimated::css {
-using namespace worklets;
-/*
- * CSSDiscreteArray is used for array interpolation when arrays need to be
- * treated as discrete values. Instead of interpolating between corresponding
- * elements of two arrays, this type interpolates between entire arrays
- * treated as single discrete values.
- */
-template <typename TValue>
-struct CSSDiscreteArray : public CSSSimpleValue<CSSDiscreteArray<TValue>> {
-  static_assert(CSSValueDerived<TValue>, "TValue must be derived from CSSValue");      
-  static constexpr bool is_discrete_value = true;
-
-  std::vector<TValue> values;
-
-  CSSDiscreteArray();
-  explicit CSSDiscreteArray(const std::vector<TValue> &values);
-  explicit CSSDiscreteArray(jsi::Runtime &rt, const jsi::Value &jsiValue);
-  explicit CSSDiscreteArray(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;
-  CSSDiscreteArray<TValue> interpolate(double progress, const CSSDiscreteArray<TValue> &other) const override;
-
-  bool operator==(const CSSDiscreteArray<TValue> &other) const;
-
-#ifndef NDEBUG
-  friend std::ostream &operator<<(std::ostream &os, const CSSDiscreteArray<TValue> &arrayValue);
-#endif // NDEBUG
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSKeyword.h>
+
+#include <sstream>
+#include <string>
+#include <vector>
+#include <worklets/Tools/JSISerializer.h>
+#include <type_traits> 
+
+namespace reanimated::css {
+using namespace worklets;
+/*
+ * CSSDiscreteArray is used for array interpolation when arrays need to be
+ * treated as discrete values. Instead of interpolating between corresponding
+ * elements of two arrays, this type interpolates between entire arrays
+ * treated as single discrete values.
+ */
+template <typename TValue>
+struct CSSDiscreteArray : public CSSSimpleValue<CSSDiscreteArray<TValue>> {
+  static_assert(CSSValueDerived<TValue>, "TValue must be derived from CSSValue");      
+  static constexpr bool is_discrete_value = true;
+
+  std::vector<TValue> values;
+
+  CSSDiscreteArray();
+  explicit CSSDiscreteArray(const std::vector<TValue> &values);
+  explicit CSSDiscreteArray(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  explicit CSSDiscreteArray(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;
+  CSSDiscreteArray<TValue> interpolate(double progress, const CSSDiscreteArray<TValue> &other) const override;
+
+  bool operator==(const CSSDiscreteArray<TValue> &other) const;
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const CSSDiscreteArray<TValue> &arrayValue);
+#endif // NDEBUG
+};
+
+} // namespace reanimated::css

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

@@ -1,81 +1,81 @@
-#include <reanimated/CSS/common/values/CSSKeyword.h>
-
-#include <string>
-
-namespace reanimated::css {
-
-template <typename TValue>
-CSSKeywordBase<TValue>::CSSKeywordBase(const char *value) : value(value) {}
-
-template <typename TValue>
-CSSKeywordBase<TValue>::CSSKeywordBase(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-  value = jsiValue.asString(rt).utf8(rt);
-}
-
-template <typename TValue>
-CSSKeywordBase<TValue>::CSSKeywordBase(const folly::dynamic &value) {
-  this->value = value.asString();
-}
-
-template <typename TValue>
-bool CSSKeywordBase<TValue>::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-  return jsiValue.isString();
-}
-
-template <typename TValue>
-bool CSSKeywordBase<TValue>::canConstruct(const folly::dynamic &value) {
-  return value.isString();
-}
-
-template <typename TValue>
-folly::dynamic CSSKeywordBase<TValue>::toDynamic() const {
-  return value;
-}
-
-template <typename TValue>
-std::string CSSKeywordBase<TValue>::toString() const {
-  return value;
-}
-
-template <typename TValue>
-bool CSSKeywordBase<TValue>::operator==(const CSSKeywordBase<TValue> &other) const {
-  return value == other.value;
-}
-
-CSSKeyword CSSKeyword::interpolate(double progress, const CSSKeyword &to) const {
-  return CSSKeyword(progress < 0.5 ? value : to.value);
-}
-
-#ifndef NDEBUG
-
-std::ostream &operator<<(std::ostream &os, const CSSKeyword &keywordValue) {
-  os << "CSSKeyword(" << keywordValue.toString() << ")";
-  return os;
-}
-
-#endif // NDEBUG
-
-CSSDisplay CSSDisplay::interpolate(double progress, const CSSDisplay &to) const {
-  if (value == "none" && progress > 0) {
-    return CSSDisplay(to.value);
-  }
-  if (to.value == "none" && progress < 1) {
-    return CSSDisplay(value);
-  }
-  return CSSDisplay(progress < 0.5 ? value : to.value);
-}
-
-#ifndef NDEBUG
-
-std::ostream &operator<<(std::ostream &os, const CSSDisplay &displayValue) {
-  os << "CSSDisplay(" << displayValue.toString() << ")";
-  return os;
-}
-
-#endif // NDEBUG
-
-// Explicit template instantiations
-template class CSSKeywordBase<CSSKeyword>;
-template class CSSKeywordBase<CSSDisplay>;
-
-} // namespace reanimated::css
+#include <reanimated/CSS/common/values/CSSKeyword.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+template <typename TValue>
+CSSKeywordBase<TValue>::CSSKeywordBase(const char *value) : value(value) {}
+
+template <typename TValue>
+CSSKeywordBase<TValue>::CSSKeywordBase(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  value = jsiValue.asString(rt).utf8(rt);
+}
+
+template <typename TValue>
+CSSKeywordBase<TValue>::CSSKeywordBase(const folly::dynamic &value) {
+  this->value = value.asString();
+}
+
+template <typename TValue>
+bool CSSKeywordBase<TValue>::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  return jsiValue.isString();
+}
+
+template <typename TValue>
+bool CSSKeywordBase<TValue>::canConstruct(const folly::dynamic &value) {
+  return value.isString();
+}
+
+template <typename TValue>
+folly::dynamic CSSKeywordBase<TValue>::toDynamic() const {
+  return value;
+}
+
+template <typename TValue>
+std::string CSSKeywordBase<TValue>::toString() const {
+  return value;
+}
+
+template <typename TValue>
+bool CSSKeywordBase<TValue>::operator==(const CSSKeywordBase<TValue> &other) const {
+  return value == other.value;
+}
+
+CSSKeyword CSSKeyword::interpolate(double progress, const CSSKeyword &to) const {
+  return CSSKeyword(progress < 0.5 ? value : to.value);
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const CSSKeyword &keywordValue) {
+  os << "CSSKeyword(" << keywordValue.toString() << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+CSSDisplay CSSDisplay::interpolate(double progress, const CSSDisplay &to) const {
+  if (value == "none" && progress > 0) {
+    return CSSDisplay(to.value);
+  }
+  if (to.value == "none" && progress < 1) {
+    return CSSDisplay(value);
+  }
+  return CSSDisplay(progress < 0.5 ? value : to.value);
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const CSSDisplay &displayValue) {
+  os << "CSSDisplay(" << displayValue.toString() << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+// Explicit template instantiations
+template class CSSKeywordBase<CSSKeyword>;
+template class CSSKeywordBase<CSSDisplay>;
+
+} // namespace reanimated::css

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

@@ -1,53 +1,53 @@
-#pragma once
-
-#include <reanimated/CSS/common/values/CSSValue.h>
-
-#include <string>
-
-namespace reanimated::css {
-
-template <typename TValue>
-class CSSKeywordBase : public CSSSimpleValue<TValue> {
- public:
-  static constexpr bool is_discrete_value = true;
-
-  CSSKeywordBase() = default;
-  explicit CSSKeywordBase(const char *value);
-  explicit CSSKeywordBase(jsi::Runtime &rt, const jsi::Value &jsiValue);
-  explicit CSSKeywordBase(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;
-
-  bool operator==(const CSSKeywordBase &other) const;
-
- protected:
-  std::string value;
-};
-
-struct CSSKeyword : public CSSKeywordBase<CSSKeyword> {
-  using CSSKeywordBase<CSSKeyword>::CSSKeywordBase;
-  using CSSKeywordBase<CSSKeyword>::canConstruct;
-
-  CSSKeyword interpolate(double progress, const CSSKeyword &to) const override;
-
-#ifndef NDEBUG
-  friend std::ostream &operator<<(std::ostream &os, const CSSKeyword &keywordValue);
-#endif // NDEBUG
-};
-
-struct CSSDisplay : public CSSKeywordBase<CSSDisplay> {
-  using CSSKeywordBase<CSSDisplay>::CSSKeywordBase;
-  using CSSKeywordBase<CSSDisplay>::canConstruct;
-
-  CSSDisplay interpolate(double progress, const CSSDisplay &to) const override;
-
-#ifndef NDEBUG
-  friend std::ostream &operator<<(std::ostream &os, const CSSDisplay &displayValue);
-#endif // NDEBUG
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSValue.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+template <typename TValue>
+class CSSKeywordBase : public CSSSimpleValue<TValue> {
+ public:
+  static constexpr bool is_discrete_value = true;
+
+  CSSKeywordBase() = default;
+  explicit CSSKeywordBase(const char *value);
+  explicit CSSKeywordBase(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  explicit CSSKeywordBase(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;
+
+  bool operator==(const CSSKeywordBase &other) const;
+
+ protected:
+  std::string value;
+};
+
+struct CSSKeyword : public CSSKeywordBase<CSSKeyword> {
+  using CSSKeywordBase<CSSKeyword>::CSSKeywordBase;
+  using CSSKeywordBase<CSSKeyword>::canConstruct;
+
+  CSSKeyword interpolate(double progress, const CSSKeyword &to) const override;
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const CSSKeyword &keywordValue);
+#endif // NDEBUG
+};
+
+struct CSSDisplay : public CSSKeywordBase<CSSDisplay> {
+  using CSSKeywordBase<CSSDisplay>::CSSKeywordBase;
+  using CSSKeywordBase<CSSDisplay>::canConstruct;
+
+  CSSDisplay interpolate(double progress, const CSSDisplay &to) const override;
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const CSSDisplay &displayValue);
+#endif // NDEBUG
+};
+
+} // namespace reanimated::css

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

@@ -1,122 +1,122 @@
-#include <reanimated/CSS/common/values/CSSLength.h>
-
-#include <string>
-
-namespace reanimated::css {
-
-CSSLength::CSSLength() : value(0), isRelative(false) {}
-
-CSSLength::CSSLength(const double value) : value(value), isRelative(false) {}
-
-CSSLength::CSSLength(const double value, const bool isRelative) : value(value), isRelative(isRelative) {}
-
-CSSLength::CSSLength(const char *value) {
-  if (!canConstruct(value)) {
-    throw std::invalid_argument("[Reanimated] CSSLength: Invalid value: " + std::string(value));
-  }
-
-  std::string str = value;
-  str.pop_back();
-  this->value = std::stod(str) / 100;
-  this->isRelative = true;
-}
-
-CSSLength::CSSLength(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-  if (jsiValue.isNumber()) {
-    this->value = jsiValue.asNumber();
-    this->isRelative = false;
-  } else {
-    *this = CSSLength(jsiValue.asString(rt).utf8(rt));
-  }
-}
-
-CSSLength::CSSLength(const folly::dynamic &value) {
-  if (value.isNumber()) {
-    this->value = value.getDouble();
-    this->isRelative = false;
-  } else {
-    *this = CSSLength(value.asString().c_str());
-  }
-}
-
-bool CSSLength::canConstruct(const std::string &value) {
-  return !value.empty() && value.back() == '%';
-}
-
-bool CSSLength::canConstruct(const char *value) {
-  return canConstruct(std::string(value));
-}
-
-bool CSSLength::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-  return jsiValue.isNumber() || (jsiValue.isString() && canConstruct(jsiValue.getString(rt).utf8(rt)));
-}
-
-bool CSSLength::canConstruct(const folly::dynamic &value) {
-  return value.isNumber() || (value.isString() && canConstruct(value.getString()));
-}
-
-folly::dynamic CSSLength::toDynamic() const {
-  if (isRelative) {
-    return std::to_string(value * 100) + "%";
-  }
-  return value;
-}
-
-std::string CSSLength::toString() const {
-  return isRelative ? (std::to_string(value * 100) + "%") : std::to_string(value);
-}
-
-CSSLength CSSLength::interpolate(
-    const double progress,
-    const CSSLength &to,
-    const ResolvableValueInterpolationContext &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 CSSLength(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 CSSLength(resolvedFrom.value() + (resolvedTo.value() - resolvedFrom.value()) * progress);
-}
-
-std::optional<double> CSSLength::resolve(const ResolvableValueInterpolationContext &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 CSSLength::operator==(const CSSLength &other) const {
-  return value == other.value && isRelative == other.isRelative;
-}
-
-#ifndef NDEBUG
-
-std::ostream &operator<<(std::ostream &os, const CSSLength &value) {
-  os << "CSSLength(" << value.toString() << ")";
-  return os;
-}
-
-#endif // NDEBUG
-
-} // namespace reanimated::css
+#include <reanimated/CSS/common/values/CSSLength.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+CSSLength::CSSLength() : value(0), isRelative(false) {}
+
+CSSLength::CSSLength(const double value) : value(value), isRelative(false) {}
+
+CSSLength::CSSLength(const double value, const bool isRelative) : value(value), isRelative(isRelative) {}
+
+CSSLength::CSSLength(const char *value) {
+  if (!canConstruct(value)) {
+    throw std::invalid_argument("[Reanimated] CSSLength: Invalid value: " + std::string(value));
+  }
+
+  std::string str = value;
+  str.pop_back();
+  this->value = std::stod(str) / 100;
+  this->isRelative = true;
+}
+
+CSSLength::CSSLength(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  if (jsiValue.isNumber()) {
+    this->value = jsiValue.asNumber();
+    this->isRelative = false;
+  } else {
+    *this = CSSLength(jsiValue.asString(rt).utf8(rt));
+  }
+}
+
+CSSLength::CSSLength(const folly::dynamic &value) {
+  if (value.isNumber()) {
+    this->value = value.getDouble();
+    this->isRelative = false;
+  } else {
+    *this = CSSLength(value.asString().c_str());
+  }
+}
+
+bool CSSLength::canConstruct(const std::string &value) {
+  return !value.empty() && value.back() == '%';
+}
+
+bool CSSLength::canConstruct(const char *value) {
+  return canConstruct(std::string(value));
+}
+
+bool CSSLength::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  return jsiValue.isNumber() || (jsiValue.isString() && canConstruct(jsiValue.getString(rt).utf8(rt)));
+}
+
+bool CSSLength::canConstruct(const folly::dynamic &value) {
+  return value.isNumber() || (value.isString() && canConstruct(value.getString()));
+}
+
+folly::dynamic CSSLength::toDynamic() const {
+  if (isRelative) {
+    return std::to_string(value * 100) + "%";
+  }
+  return value;
+}
+
+std::string CSSLength::toString() const {
+  return isRelative ? (std::to_string(value * 100) + "%") : std::to_string(value);
+}
+
+CSSLength CSSLength::interpolate(
+    const double progress,
+    const CSSLength &to,
+    const ResolvableValueInterpolationContext &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 CSSLength(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 CSSLength(resolvedFrom.value() + (resolvedTo.value() - resolvedFrom.value()) * progress);
+}
+
+std::optional<double> CSSLength::resolve(const ResolvableValueInterpolationContext &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 CSSLength::operator==(const CSSLength &other) const {
+  return value == other.value && isRelative == other.isRelative;
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const CSSLength &value) {
+  os << "CSSLength(" << value.toString() << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+} // namespace reanimated::css