@react-native-ohos/react-native-reanimated 3.18.2-rc.2 → 4.0.1

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

@@ -0,0 +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

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

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

@@ -0,0 +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

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

@@ -0,0 +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

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

@@ -0,0 +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

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

@@ -0,0 +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

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

@@ -0,0 +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

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

@@ -0,0 +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