@react-native-ohos/react-native-reanimated 3.18.1-rc.6 → 4.0.0-rc.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/registries/CSSKeyframesRegistry.cpp

@@ -0,0 +1,45 @@
+#include <reanimated/CSS/registries/CSSKeyframesRegistry.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace reanimated::css {
+
+CSSKeyframesRegistry::CSSKeyframesRegistry(const std::shared_ptr<ViewStylesRepository> &viewStylesRepository)
+    : viewStylesRepository_(viewStylesRepository) {}
+
+const CSSKeyframesConfig &CSSKeyframesRegistry::get(
+    const std::string &animationName,
+    const std::string &componentName) {
+  const auto &registryIt = registry_.find(animationName);
+  if (registryIt == registry_.end()) {
+    throw std::runtime_error("[Reanimated] No keyframes with name `" + animationName + "` were registered");
+  }
+
+  const auto &keyframesByComponentName = registryIt->second;
+  const auto &keyframesByComponentNameIt = keyframesByComponentName.find(componentName);
+  if (keyframesByComponentNameIt == keyframesByComponentName.end()) {
+    throw std::runtime_error(
+        "[Reanimated] No keyframes with name `" + animationName + "` were registered for component `" + componentName +
+        "`");
+  }
+
+  return keyframesByComponentNameIt->second;
+}
+
+void CSSKeyframesRegistry::set(
+    const std::string &animationName,
+    const std::string &componentName,
+    CSSKeyframesConfig &&config) {
+  registry_[animationName][componentName] = std::move(config);
+}
+
+void CSSKeyframesRegistry::remove(const std::string &animationName, const std::string &componentName) {
+  registry_[animationName].erase(componentName);
+  if (registry_[animationName].empty()) {
+    registry_.erase(animationName);
+  }
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/registries/CSSKeyframesRegistry.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <reanimated/CSS/configs/CSSKeyframesConfig.h>
+#include <reanimated/CSS/interpolation/styles/AnimationStyleInterpolator.h>
+#include <reanimated/CSS/misc/ViewStylesRepository.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+namespace reanimated::css {
+
+class CSSKeyframesRegistry {
+ public:
+  explicit CSSKeyframesRegistry(const std::shared_ptr<ViewStylesRepository> &viewStylesRepository);
+
+  const CSSKeyframesConfig &get(const std::string &animationName, const std::string &componentName);
+  void set(const std::string &animationName, const std::string &componentName, CSSKeyframesConfig &&config);
+  void remove(const std::string &animationName, const std::string &componentName);
+
+ private:
+  using ConfigsByComponentName = std::unordered_map<std::string, CSSKeyframesConfig>;
+
+  std::unordered_map<std::string, ConfigsByComponentName> registry_;
+  const std::shared_ptr<ViewStylesRepository> viewStylesRepository_;
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/registries/CSSTransitionsRegistry.cpp

@@ -0,0 +1,167 @@
+#include <reanimated/CSS/registries/CSSTransitionsRegistry.h>
+
+#include <memory>
+#include <utility>
+
+namespace reanimated::css {
+
+CSSTransitionsRegistry::CSSTransitionsRegistry(
+    const std::shared_ptr<StaticPropsRegistry> &staticPropsRegistry,
+    const GetAnimationTimestampFunction &getCurrentTimestamp)
+    : getCurrentTimestamp_(getCurrentTimestamp), staticPropsRegistry_(staticPropsRegistry) {}
+
+bool CSSTransitionsRegistry::isEmpty() const {
+  // The registry is empty if has no registered animations and no updates
+  // stored in the updates registry
+  return UpdatesRegistry::isEmpty() && registry_.empty();
+}
+
+bool CSSTransitionsRegistry::hasUpdates() const {
+  return !runningTransitionTags_.empty() || !delayedTransitionsManager_.empty();
+}
+
+void CSSTransitionsRegistry::add(const std::shared_ptr<CSSTransition> &transition) {
+  const auto &shadowNode = transition->getShadowNode();
+  const auto viewTag = shadowNode->getTag();
+
+  registry_.insert({viewTag, transition});
+  PropsObserver observer = createPropsObserver(viewTag);
+  staticPropsRegistry_->setObserver(viewTag, std::move(observer));
+}
+
+void CSSTransitionsRegistry::remove(const Tag viewTag) {
+  removeFromUpdatesRegistry(viewTag);
+  staticPropsRegistry_->removeObserver(viewTag);
+  delayedTransitionsManager_.remove(viewTag);
+  runningTransitionTags_.erase(viewTag);
+  registry_.erase(viewTag);
+}
+
+void CSSTransitionsRegistry::updateSettings(const Tag viewTag, const PartialCSSTransitionConfig &config) {
+  const auto &transition = registry_[viewTag];
+  transition->updateSettings(config);
+
+  // Replace style overrides with the new ones if transition properties were
+  // updated (we want to keep overrides only for transitioned properties)
+  if (config.properties.has_value()) {
+    updateInUpdatesRegistry(transition, transition->getCurrentInterpolationStyle());
+  }
+}
+
+void CSSTransitionsRegistry::update(const double timestamp) {
+  // Activate all delayed transitions that should start now
+  activateDelayedTransitions(timestamp);
+
+  // Iterate over active transitions and update them
+  for (auto it = runningTransitionTags_.begin(); it != runningTransitionTags_.end();) {
+    const auto &viewTag = *it;
+    const auto &transition = registry_[viewTag];
+
+    const folly::dynamic &updates = transition->update(timestamp);
+    if (!updates.empty()) {
+      addUpdatesToBatch(transition->getShadowNode(), updates);
+    }
+
+    // We remove transition from running and schedule it when animation of one
+    // of properties has finished and the other one is still delayed
+    const auto &minDelay = transition->getMinDelay(timestamp);
+    if (minDelay > 0) {
+      delayedTransitionsManager_.add(timestamp + transition->getMinDelay(timestamp), viewTag);
+    }
+
+    if (transition->getState() != TransitionProgressState::Running) {
+      it = runningTransitionTags_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
+void CSSTransitionsRegistry::activateDelayedTransitions(const double timestamp) {
+  while (!delayedTransitionsManager_.empty() && delayedTransitionsManager_.top().timestamp <= timestamp) {
+    const auto [_, viewTag] = delayedTransitionsManager_.pop();
+
+    // Add only these transitions which weren't removed in the meantime
+    if (registry_.find(viewTag) != registry_.end()) {
+      runningTransitionTags_.insert(viewTag);
+    }
+  }
+}
+
+void CSSTransitionsRegistry::scheduleOrActivateTransition(const std::shared_ptr<CSSTransition> &transition) {
+  const auto viewTag = transition->getViewTag();
+  const auto currentTimestamp = getCurrentTimestamp_();
+  const auto minDelay = transition->getMinDelay(currentTimestamp);
+
+  // Remove transition from delayed (if it is already added to delayed
+  // transitions)
+  delayedTransitionsManager_.remove(viewTag);
+
+  if (minDelay > 0) {
+    delayedTransitionsManager_.add(currentTimestamp + minDelay, viewTag);
+  } else {
+    runningTransitionTags_.insert(viewTag);
+  }
+}
+
+PropsObserver CSSTransitionsRegistry::createPropsObserver(const Tag viewTag) {
+  return [weakThis = weak_from_this(), viewTag](const folly::dynamic &oldProps, const folly::dynamic &newProps) {
+    auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
+
+    const auto &transition = strongThis->registry_[viewTag];
+    const auto allowedProperties = transition->getAllowedProperties(oldProps, newProps);
+
+    const auto changedProps = getChangedProps(oldProps, newProps, allowedProperties);
+
+    if (changedProps.changedPropertyNames.empty()) {
+      return;
+    }
+
+    {
+      std::lock_guard<std::mutex> lock{strongThis->mutex_};
+
+      const auto &shadowNode = transition->getShadowNode();
+      const auto &lastUpdates = strongThis->getUpdatesFromRegistry(shadowNode->getTag());
+      const auto &transitionStartStyle = transition->run(changedProps, lastUpdates, strongThis->getCurrentTimestamp_());
+      strongThis->updateInUpdatesRegistry(transition, transitionStartStyle);
+      strongThis->scheduleOrActivateTransition(transition);
+    }
+  };
+}
+
+void CSSTransitionsRegistry::updateInUpdatesRegistry(
+    const std::shared_ptr<CSSTransition> &transition,
+    const folly::dynamic &updates) {
+  const auto &shadowNode = transition->getShadowNode();
+  const auto &lastUpdates = getUpdatesFromRegistry(shadowNode->getTag());
+  const auto &transitionProperties = transition->getProperties();
+
+  folly::dynamic filteredUpdates = folly::dynamic::object;
+
+  if (!transitionProperties.has_value()) {
+    // If transitionProperty is set to 'all' (optional has no value), we have
+    // to keep the result of the previous transition updated with the new
+    // transition starting values
+    if (!lastUpdates.empty()) {
+      filteredUpdates = lastUpdates;
+    }
+  } else if (!lastUpdates.empty()) {
+    // Otherwise, we keep only allowed properties from the last updates
+    // and update the object with the new transition starting values
+    for (const auto &prop : transitionProperties.value()) {
+      if (lastUpdates.count(prop)) {
+        filteredUpdates[prop] = lastUpdates[prop];
+      }
+    }
+  }
+
+  // updated object contains only allowed properties so we don't need
+  // to do additional filtering here
+  filteredUpdates.update(updates);
+  setInUpdatesRegistry(shadowNode, filteredUpdates);
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/registries/CSSTransitionsRegistry.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <reanimated/CSS/core/CSSTransition.h>
+#include <reanimated/CSS/registries/StaticPropsRegistry.h>
+#include <reanimated/CSS/utils/DelayedItemsManager.h>
+#include <reanimated/CSS/utils/props.h>
+#include <reanimated/Fabric/updates/UpdatesRegistry.h>
+#include <reanimated/Tools/PlatformDepMethodsHolder.h>
+
+#include <memory>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace reanimated::css {
+
+class CSSTransitionsRegistry : public UpdatesRegistry, public std::enable_shared_from_this<CSSTransitionsRegistry> {
+ public:
+  CSSTransitionsRegistry(
+      const std::shared_ptr<StaticPropsRegistry> &staticPropsRegistry,
+      const GetAnimationTimestampFunction &getCurrentTimestamp);
+
+  bool isEmpty() const override;
+  bool hasUpdates() const;
+
+  void add(const std::shared_ptr<CSSTransition> &transition);
+  void updateSettings(Tag viewTag, const PartialCSSTransitionConfig &config);
+  void remove(Tag viewTag) override;
+
+  void update(double timestamp);
+
+ private:
+  using Registry = std::unordered_map<Tag, std::shared_ptr<CSSTransition>>;
+
+  const GetAnimationTimestampFunction &getCurrentTimestamp_;
+  const std::shared_ptr<StaticPropsRegistry> staticPropsRegistry_;
+
+  Registry registry_;
+
+  std::unordered_set<Tag> runningTransitionTags_;
+  DelayedItemsManager<Tag> delayedTransitionsManager_;
+
+  void activateDelayedTransitions(double timestamp);
+  void scheduleOrActivateTransition(const std::shared_ptr<CSSTransition> &transition);
+  PropsObserver createPropsObserver(Tag viewTag);
+  void updateInUpdatesRegistry(const std::shared_ptr<CSSTransition> &transition, const folly::dynamic &updates);
+};
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/registries/StaticPropsRegistry.cpp

@@ -0,0 +1,61 @@
+#include <reanimated/CSS/registries/StaticPropsRegistry.h>
+
+#include <utility>
+
+namespace reanimated::css {
+
+void StaticPropsRegistry::set(jsi::Runtime &rt, const Tag viewTag, const jsi::Value &props) {
+  if (props.isNull() || props.isUndefined()) {
+    remove(viewTag);
+  } else {
+    const auto newProps = dynamicFromValue(rt, props);
+    if (has(viewTag)) {
+      notifyObservers(viewTag, get(viewTag), newProps);
+    }
+    registry_[viewTag] = newProps;
+  }
+}
+
+folly::dynamic StaticPropsRegistry::get(const Tag viewTag) const {
+  auto it = registry_.find(viewTag);
+  if (it == registry_.end()) {
+    return nullptr;
+  }
+  return it->second;
+}
+
+bool StaticPropsRegistry::has(const Tag viewTag) const {
+  return registry_.find(viewTag) != registry_.end();
+}
+
+void StaticPropsRegistry::remove(const Tag viewTag) {
+  registry_.erase(viewTag);
+}
+
+bool StaticPropsRegistry::isEmpty() const {
+  return registry_.empty() && observers_.empty();
+}
+
+bool StaticPropsRegistry::hasObservers(const Tag viewTag) const {
+  return observers_.find(viewTag) != observers_.end();
+}
+
+void StaticPropsRegistry::setObserver(const Tag viewTag, PropsObserver observer) {
+  observers_[viewTag] = std::move(observer);
+}
+
+void StaticPropsRegistry::removeObserver(const Tag viewTag) {
+  observers_.erase(viewTag);
+}
+
+void StaticPropsRegistry::notifyObservers(
+    const Tag viewTag,
+    const folly::dynamic &oldProps,
+    const folly::dynamic &newProps) {
+  auto observerIt = observers_.find(viewTag);
+  if (observerIt != observers_.end()) {
+    observerIt->second(oldProps, newProps);
+  }
+}
+
+} // namespace reanimated::css

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/CSS/registries/StaticPropsRegistry.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <react/renderer/core/ShadowNode.h>
+
+#include <unordered_map>
+
+namespace reanimated::css {
+
+using namespace facebook;
+using namespace react;
+
+using PropsObserver = std::function<void(const folly::dynamic &oldProps, const folly::dynamic &newProps)>;
+
+class StaticPropsRegistry {
+ public:
+  void set(jsi::Runtime &rt, Tag viewTag, const jsi::Value &props);
+  folly::dynamic get(Tag viewTag) const;
+  bool has(Tag viewTag) const;
+  void remove(Tag viewTag);
+  bool isEmpty() const;
+
+  bool hasObservers(Tag viewTag) const;
+  void setObserver(Tag viewTag, PropsObserver observer);
+  void removeObserver(Tag viewTag);
+
+ private:
+  std::unordered_map<Tag, folly::dynamic> registry_;
+  std::unordered_map<Tag, PropsObserver> observers_;
+
+  void notifyObservers(Tag viewTag, const folly::dynamic &oldProps, const folly::dynamic &newProps);
+};
+
+} // namespace reanimated::css

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

@@ -0,0 +1,80 @@
+#include <reanimated/CSS/svg/values/SVGBrush.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+SVGBrush::SVGBrush(jsi::Runtime &rt, const jsi::Value &value)
+    : CSSColorBase<SVGBrushType, SVGBrush>(SVGBrushType::Transparent) {
+  if (value.isBool()) {
+    *this = SVGBrush(value.getBool());
+  } else if (value.isNumber()) {
+    *this = SVGBrush(static_cast<int64_t>(value.getNumber()));
+  } else if (value.asString(rt).utf8(rt) == "currentColor") {
+    colorType = SVGBrushType::CurrentColor;
+  }
+}
+
+SVGBrush::SVGBrush(const folly::dynamic &value) : CSSColorBase<SVGBrushType, SVGBrush>(SVGBrushType::Transparent) {
+  if (value.isBool()) {
+    *this = SVGBrush(value.getBool());
+  } else if (value.isNumber()) {
+    *this = SVGBrush(value.asInt());
+  } else if (value.asString() == "currentColor") {
+    colorType = SVGBrushType::CurrentColor;
+  }
+}
+
+bool SVGBrush::canConstruct(jsi::Runtime &rt, const jsi::Value &jsiValue) {
+  return jsiValue.isNumber() || jsiValue.isBool() ||
+      (jsiValue.isString() && jsiValue.getString(rt).utf8(rt) == "currentColor");
+}
+
+bool SVGBrush::canConstruct(const folly::dynamic &value) {
+  return value.isNumber() || value.isBool() || value.asString() == "currentColor";
+}
+
+folly::dynamic SVGBrush::toDynamic() const {
+  switch (colorType) {
+    case SVGBrushType::Rgba:
+      return (channels[3] << 24) | (channels[0] << 16) | (channels[1] << 8) | channels[2];
+    case SVGBrushType::CurrentColor:
+      return nullptr; // currentColor is represented as nullptr in SVG
+    default:
+      return 0; // Transparent
+  }
+}
+
+std::string SVGBrush::toString() const {
+  switch (colorType) {
+    case SVGBrushType::Rgba:
+      return "rgba(" + std::to_string(channels[0]) + "," + std::to_string(channels[1]) + "," +
+          std::to_string(channels[2]) + "," + std::to_string(channels[3]) + ")";
+    case SVGBrushType::CurrentColor:
+      return "currentColor";
+    default:
+      return "transparent";
+  }
+}
+
+SVGBrush SVGBrush::interpolate(double progress, const SVGBrush &to) const {
+  if (!isInterpolatable()) {
+    return progress < 0.5 ? *this : to;
+  }
+  return CSSColorBase<SVGBrushType, SVGBrush>::interpolate(progress, to);
+}
+
+bool SVGBrush::isInterpolatable() const {
+  return colorType == SVGBrushType::Rgba || colorType == SVGBrushType::Transparent;
+}
+
+#ifndef NDEBUG
+
+std::ostream &operator<<(std::ostream &os, const SVGBrush &colorValue) {
+  os << "SVGBrush(" << colorValue.toString() << ")";
+  return os;
+}
+
+#endif // NDEBUG
+
+} // namespace reanimated::css

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

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <reanimated/CSS/common/values/CSSColor.h>
+
+#include <string>
+
+namespace reanimated::css {
+
+enum class SVGBrushType : std::uint8_t {
+  Rgba,
+  Transparent,
+  CurrentColor,
+};
+
+struct SVGBrush : public CSSColorBase<SVGBrushType, SVGBrush> {
+  using CSSColorBase<SVGBrushType, SVGBrush>::CSSColorBase;
+  using CSSColorBase<SVGBrushType, SVGBrush>::operator==;
+
+  explicit SVGBrush(jsi::Runtime &rt, const jsi::Value &jsiValue);
+  explicit SVGBrush(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;
+
+  SVGBrush interpolate(double progress, const SVGBrush &to) const override;
+  bool isInterpolatable() const;
+
+#ifndef NDEBUG
+  friend std::ostream &operator<<(std::ostream &os, const SVGBrush &colorValue);
+#endif // NDEBUG
+
+ private:
+  static bool isValidColorString(const std::string &value);
+};
+
+} // namespace reanimated::css

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

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

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

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