@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/svg/values/SVGLength.cpp

@@ -1,93 +1,93 @@
-#include <reanimated/CSS/svg/values/SVGLength.h>
-
-#include <string>
-
-namespace reanimated::css {
-
-SVGLength::SVGLength() : value(0), isPercentage(false) {}
-
-SVGLength::SVGLength(const double value) : value(value), isPercentage(false) {}
-
-SVGLength::SVGLength(const double value, const bool isPercentage) : value(value), isPercentage(isPercentage) {}
-
-SVGLength::SVGLength(const char *value) {
-  if (!canConstruct(value)) {
-    throw std::invalid_argument("[Reanimated] SVGLength: Invalid value: " + std::string(value));
-  }
-
-  std::string str = value;
-  str.pop_back();
-  this->value = std::stod(str) / 100;
-  this->isPercentage = true;
-}
-
-SVGLength::SVGLength(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-  if (jsiValue.isNumber()) {
-    this->value = jsiValue.asNumber();
-    this->isPercentage = false;
-  } else {
-    *this = SVGLength(jsiValue.asString(rt).utf8(rt));
-  }
-}
-
-SVGLength::SVGLength(const folly::dynamic &value) {
-  if (value.isNumber()) {
-    this->value = value.getDouble();
-    this->isPercentage = false;
-  } else {
-    *this = SVGLength(value.asString().c_str());
-  }
-}
-
-bool SVGLength::canConstruct(const std::string &value) {
-  return !value.empty() && value.back() == '%';
-}
-
-bool SVGLength::canConstruct(const char *value) {
-  return canConstruct(std::string(value));
-}
-
-bool SVGLength::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-  return jsiValue.isNumber() || (jsiValue.isString() && canConstruct(jsiValue.getString(rt).utf8(rt)));
-}
-
-bool SVGLength::canConstruct(const folly::dynamic &value) {
-  return value.isNumber() || (value.isString() && canConstruct(value.getString()));
-}
-
-folly::dynamic SVGLength::toDynamic() const {
-  if (isPercentage) {
-    return std::to_string(value * 100) + "%";
-  }
-  return value;
-}
-
-std::string SVGLength::toString() const {
-  return std::to_string(value * (isPercentage ? 100 : 1)) + "%";
-}
-
-SVGLength SVGLength::interpolate(const double progress, const SVGLength &to) const {
-  // We can interpolate SVG length values only if both values are percentages or
-  // both are numbers. In other cases, we interpolate them as keywords.
-  if ((isPercentage == to.isPercentage) || (isPercentage && to.value == 0) || (to.isPercentage && value == 0)) {
-    return SVGLength(value + (to.value - value) * progress, isPercentage || to.isPercentage);
-  }
-
-  // Otherwise, we interpolate values as discrete values
-  return progress < 0.5 ? *this : to;
-}
-
-bool SVGLength::operator==(const SVGLength &other) const {
-  return value == other.value && isPercentage == other.isPercentage;
-}
-
-#ifndef NDEBUG
-
-std::ostream &operator<<(std::ostream &os, const SVGLength &value) {
-  os << "SVGLength(" << value.toString() << ")";
-  return os;
-}
-
-#endif // NDEBUG
-
-} // namespace reanimated::css
+#include <reanimated/CSS/svg/values/SVGLength.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+SVGLength::SVGLength() : value(0), isPercentage(false) {}
+
+SVGLength::SVGLength(const double value) : value(value), isPercentage(false) {}
+
+SVGLength::SVGLength(const double value, const bool isPercentage) : value(value), isPercentage(isPercentage) {}
+
+SVGLength::SVGLength(const char *value) {
+  if (!canConstruct(value)) {
+    throw std::invalid_argument("[Reanimated] SVGLength: Invalid value: " + std::string(value));
+  }
+
+  std::string str = value;
+  str.pop_back();
+  this->value = std::stod(str) / 100;
+  this->isPercentage = true;
+}
+
+SVGLength::SVGLength(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  if (jsiValue.isNumber()) {
+    this->value = jsiValue.asNumber();
+    this->isPercentage = false;
+  } else {
+    *this = SVGLength(jsiValue.asString(rt).utf8(rt));
+  }
+}
+
+SVGLength::SVGLength(const folly::dynamic &value) {
+  if (value.isNumber()) {
+    this->value = value.getDouble();
+    this->isPercentage = false;
+  } else {
+    *this = SVGLength(value.asString().c_str());
+  }
+}
+
+bool SVGLength::canConstruct(const std::string &value) {
+  return !value.empty() && value.back() == '%';
+}
+
+bool SVGLength::canConstruct(const char *value) {
+  return canConstruct(std::string(value));
+}
+
+bool SVGLength::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  return jsiValue.isNumber() || (jsiValue.isString() && canConstruct(jsiValue.getString(rt).utf8(rt)));
+}
+
+bool SVGLength::canConstruct(const folly::dynamic &value) {
+  return value.isNumber() || (value.isString() && canConstruct(value.getString()));
+}
+
+folly::dynamic SVGLength::toDynamic() const {
+  if (isPercentage) {
+    return std::to_string(value * 100) + "%";
+  }
+  return value;
+}
+
+std::string SVGLength::toString() const {
+  return std::to_string(value * (isPercentage ? 100 : 1)) + "%";
+}
+
+SVGLength SVGLength::interpolate(const double progress, const SVGLength &to) const {
+  // We can interpolate SVG length values only if both values are percentages or
+  // both are numbers. In other cases, we interpolate them as keywords.
+  if ((isPercentage == to.isPercentage) || (isPercentage && to.value == 0) || (to.isPercentage && value == 0)) {
+    return SVGLength(value + (to.value - value) * progress, isPercentage || to.isPercentage);
+  }
+
+  // Otherwise, we interpolate values as discrete values
+  return progress < 0.5 ? *this : to;
+}
+
+bool SVGLength::operator==(const SVGLength &other) const {
+  return value == other.value && isPercentage == other.isPercentage;
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const SVGLength &value) {
+  os << "SVGLength(" << value.toString() << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/svg/values/SVGLength.h

@@ -1,36 +1,36 @@
-#pragma once
-
-#include <reanimated/CSS/common/values/CSSValue.h>
-
-#include <string>
-
-namespace reanimated::css {
-
-struct SVGLength : public CSSSimpleValue<SVGLength> {
-  double value;
-  bool isPercentage;
-
-  SVGLength();
-  explicit SVGLength(double value);
-  explicit SVGLength(double value, bool isPercentage);
-  explicit SVGLength(const char *value);
-  explicit SVGLength(jsi::Runtime &rt, const jsi::Value &jsiValue);
-  explicit SVGLength(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;
-  SVGLength interpolate(double progress, const SVGLength &to) const override;
-
-  bool operator==(const SVGLength &other) const;
-
-#ifndef NDEBUG
-  friend std::ostream &operator<<(std::ostream &os, const SVGLength &dimension);
-#endif // NDEBUG
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSValue.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+struct SVGLength : public CSSSimpleValue<SVGLength> {
+  double value;
+  bool isPercentage;
+
+  SVGLength();
+  explicit SVGLength(double value);
+  explicit SVGLength(double value, bool isPercentage);
+  explicit SVGLength(const char *value);
+  explicit SVGLength(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  explicit SVGLength(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;
+  SVGLength interpolate(double progress, const SVGLength &to) const override;
+
+  bool operator==(const SVGLength &other) const;
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const SVGLength &dimension);
+#endif // NDEBUG
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/svg/values/SVGStrokeDashArray.cpp

@@ -1,110 +1,111 @@
-#include <reanimated/CSS/svg/values/SVGStrokeDashArray.h>
-
-#include <string>
-#include <vector>
-
-namespace reanimated::css {
-
-SVGStrokeDashArray::SVGStrokeDashArray() : values() {}
-
-SVGStrokeDashArray::SVGStrokeDashArray(const std::vector<SVGLength> &values) : values(values) {}
-
-SVGStrokeDashArray::SVGStrokeDashArray(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-  const auto &array = jsiValue.asObject(rt).asArray(rt);
-  const auto arraySize = array.size(rt);
-  values.reserve(arraySize);
-  for (size_t i = 0; i < arraySize; ++i) {
-    values.emplace_back(rt, array.getValueAtIndex(rt, i));
-  }
-}
-
-SVGStrokeDashArray::SVGStrokeDashArray(const folly::dynamic &value) {
-  for (const auto &value : value) {
-    values.emplace_back(value);
-  }
-}
-
-bool SVGStrokeDashArray::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
-  if (!jsiValue.isObject() || !jsiValue.asObject(rt).isArray(rt)) {
-    return false;
-  }
-  const auto &array = jsiValue.asObject(rt).asArray(rt);
-  for (size_t i = 0; i < array.size(rt); ++i) {
-    if (!SVGLength::canConstruct(rt, array.getValueAtIndex(rt, i))) {
-      return false;
-    }
-  }
-  return true;
-}
-
-bool SVGStrokeDashArray::canConstruct(const folly::dynamic &value) {
-  return value.isArray() &&
-      std::all_of(value.begin(), value.end(), [](const auto &value) { return SVGLength::canConstruct(value); });
-}
-
-folly::dynamic SVGStrokeDashArray::toDynamic() const {
-  folly::dynamic array = folly::dynamic::array;
-  array.reserve(values.size());
-  for (const auto &value : values) {
-    array.push_back(value.toDynamic());
-  }
-  return array;
-}
-
-std::string SVGStrokeDashArray::toString() const {
-  std::stringstream ss;
-  ss << "{";
-  for (const auto &value : values) {
-    ss << value.toString();
-    if (&value != &values.back()) {
-      ss << ", ";
-    }
-  }
-  ss << "}";
-  return ss.str();
-}
-
-SVGStrokeDashArray SVGStrokeDashArray::interpolate(double progress, const SVGStrokeDashArray &to) const {
-  std::vector<SVGLength> result;
-  auto fromValues = values;
-  auto toValues = to.values;
-
-  // If one of the arrays is empty, we take the fist value from the second
-  // one and put it as the only element of the first (empty) array
-  // (this is how it works on the web)
-  if (fromValues.size() == 0 && toValues.size() > 0) {
-    fromValues = {toValues[0]};
-  }
-  if (toValues.size() == 0 && fromValues.size() > 0) {
-    toValues = {fromValues[0]};
-  }
-
-  const auto fromSize = fromValues.size();
-  const auto toSize = toValues.size();
-
-  // We need to find the least common multiple of the two arrays to get
-  // a smooth interpolation of the dash array pattern
-  const auto resultSize = std::lcm(fromSize, toSize);
-  result.reserve(resultSize);
-
-  for (size_t i = 0; i < resultSize; i++) {
-    result.emplace_back(fromValues[i % fromSize].interpolate(progress, toValues[i % toSize]));
-  }
-
-  return SVGStrokeDashArray(result);
-}
-
-bool SVGStrokeDashArray::operator==(const SVGStrokeDashArray &other) const {
-  return values == other.values;
-}
-
-#ifndef NDEBUG
-
-std::ostream &operator<<(std::ostream &os, const SVGStrokeDashArray &strokeDashArray) {
-  os << "SVGStrokeDashArray(" << strokeDashArray.toString() << ")";
-  return os;
-}
-
-#endif // NDEBUG
-
-} // namespace reanimated::css
+#include <reanimated/CSS/svg/values/SVGStrokeDashArray.h>
+
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace reanimated::css {
+
+SVGStrokeDashArray::SVGStrokeDashArray() : values() {}
+
+SVGStrokeDashArray::SVGStrokeDashArray(const std::vector<SVGLength> &values) : values(values) {}
+
+SVGStrokeDashArray::SVGStrokeDashArray(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  const auto &array = jsiValue.asObject(rt).asArray(rt);
+  const auto arraySize = array.size(rt);
+  values.reserve(arraySize);
+  for (size_t i = 0; i < arraySize; ++i) {
+    values.emplace_back(rt, array.getValueAtIndex(rt, i));
+  }
+}
+
+SVGStrokeDashArray::SVGStrokeDashArray(const folly::dynamic &value) {
+  for (const auto &value : value) {
+    values.emplace_back(value);
+  }
+}
+
+bool SVGStrokeDashArray::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  if (!jsiValue.isObject() || !jsiValue.asObject(rt).isArray(rt)) {
+    return false;
+  }
+  const auto &array = jsiValue.asObject(rt).asArray(rt);
+  for (size_t i = 0; i < array.size(rt); ++i) {
+    if (!SVGLength::canConstruct(rt, array.getValueAtIndex(rt, i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SVGStrokeDashArray::canConstruct(const folly::dynamic &value) {
+  return value.isArray() &&
+      std::all_of(value.begin(), value.end(), [](const auto &value) { return SVGLength::canConstruct(value); });
+}
+
+folly::dynamic SVGStrokeDashArray::toDynamic() const {
+  folly::dynamic array = folly::dynamic::array;
+  array.reserve(values.size());
+  for (const auto &value : values) {
+    array.push_back(value.toDynamic());
+  }
+  return array;
+}
+
+std::string SVGStrokeDashArray::toString() const {
+  std::stringstream ss;
+  ss << "{";
+  for (const auto &value : values) {
+    ss << value.toString();
+    if (&value != &values.back()) {
+      ss << ", ";
+    }
+  }
+  ss << "}";
+  return ss.str();
+}
+
+SVGStrokeDashArray SVGStrokeDashArray::interpolate(double progress, const SVGStrokeDashArray &to) const {
+  std::vector<SVGLength> result;
+  auto fromValues = values;
+  auto toValues = to.values;
+
+  // If one of the arrays is empty, we take the fist value from the second
+  // one and put it as the only element of the first (empty) array
+  // (this is how it works on the web)
+  if (fromValues.size() == 0 && toValues.size() > 0) {
+    fromValues = {toValues[0]};
+  }
+  if (toValues.size() == 0 && fromValues.size() > 0) {
+    toValues = {fromValues[0]};
+  }
+
+  const auto fromSize = fromValues.size();
+  const auto toSize = toValues.size();
+
+  // We need to find the least common multiple of the two arrays to get
+  // a smooth interpolation of the dash array pattern
+  const auto resultSize = std::lcm(fromSize, toSize);
+  result.reserve(resultSize);
+
+  for (size_t i = 0; i < resultSize; i++) {
+    result.emplace_back(fromValues[i % fromSize].interpolate(progress, toValues[i % toSize]));
+  }
+
+  return SVGStrokeDashArray(result);
+}
+
+bool SVGStrokeDashArray::operator==(const SVGStrokeDashArray &other) const {
+  return values == other.values;
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const SVGStrokeDashArray &strokeDashArray) {
+  os << "SVGStrokeDashArray(" << strokeDashArray.toString() << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/svg/values/SVGStrokeDashArray.h

@@ -1,33 +1,33 @@
-#pragma once
-
-#include <reanimated/CSS/svg/values/SVGLength.h>
-
-#include <numeric>
-#include <string>
-#include <vector>
-
-namespace reanimated::css {
-
-struct SVGStrokeDashArray : public CSSSimpleValue<SVGStrokeDashArray> {
-  std::vector<SVGLength> values;
-
-  SVGStrokeDashArray();
-  explicit SVGStrokeDashArray(const std::vector<SVGLength> &values);
-  explicit SVGStrokeDashArray(jsi::Runtime &rt, const jsi::Value &jsiValue);
-  explicit SVGStrokeDashArray(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;
-  SVGStrokeDashArray interpolate(double progress, const SVGStrokeDashArray &to) const override;
-
-  bool operator==(const SVGStrokeDashArray &other) const;
-
-#ifndef NDEBUG
-  friend std::ostream &operator<<(std::ostream &os, const SVGStrokeDashArray &strokeDashArray);
-#endif // NDEBUG
-};
-
-} // namespace reanimated::css
+#pragma once
+
+#include <reanimated/CSS/svg/values/SVGLength.h>
+
+#include <numeric>
+#include <string>
+#include <vector>
+
+namespace reanimated::css {
+
+struct SVGStrokeDashArray : public CSSSimpleValue<SVGStrokeDashArray> {
+  std::vector<SVGLength> values;
+
+  SVGStrokeDashArray();
+  explicit SVGStrokeDashArray(const std::vector<SVGLength> &values);
+  explicit SVGStrokeDashArray(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  explicit SVGStrokeDashArray(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;
+  SVGStrokeDashArray interpolate(double progress, const SVGStrokeDashArray &to) const override;
+
+  bool operator==(const SVGStrokeDashArray &other) const;
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const SVGStrokeDashArray &strokeDashArray);
+#endif // NDEBUG
+};
+
+} // namespace reanimated::css