react-nitro-yoga 0.0.0-stage → 0.0.1-alpha.7

package/yoga/yoga/node/Node.h

@@ -0,0 +1,372 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <cstdio>
+#include <vector>
+
+#include <yoga/Yoga.h>
+#include <yoga/node/LayoutableChildren.h>
+
+#include <yoga/config/Config.h>
+#include <yoga/enums/Dimension.h>
+#include <yoga/enums/Direction.h>
+#include <yoga/enums/Edge.h>
+#include <yoga/enums/Errata.h>
+#include <yoga/enums/MeasureMode.h>
+#include <yoga/enums/NodeType.h>
+#include <yoga/enums/PhysicalEdge.h>
+#include <yoga/node/LayoutResults.h>
+#include <yoga/style/Style.h>
+
+// Tag struct used to form the opaque YGNodeRef for the public C API
+struct YGNode {};
+
+namespace facebook::yoga {
+
+class YG_EXPORT Node : public ::YGNode {
+ public:
+  using LayoutableChildren = yoga::LayoutableChildren<Node>;
+  Node();
+  explicit Node(const Config* config);
+
+  Node(Node&& node) noexcept;
+
+  // Does not expose true value semantics, as children are not cloned eagerly.
+  // Should we remove this?
+  Node(const Node& node) = default;
+
+  // assignment means potential leaks of existing children, or alternatively
+  // freeing unowned memory, double free, or freeing stack memory.
+  Node& operator=(const Node&) = delete;
+
+  // Getters
+  void* getContext() const {
+    return context_;
+  }
+
+  bool alwaysFormsContainingBlock() const {
+    return alwaysFormsContainingBlock_;
+  }
+
+  bool getHasNewLayout() const {
+    return hasNewLayout_;
+  }
+
+  NodeType getNodeType() const {
+    return nodeType_;
+  }
+
+  bool hasMeasureFunc() const noexcept {
+    return measureFunc_ != nullptr;
+  }
+
+  YGSize measure(
+      float availableWidth,
+      MeasureMode widthMode,
+      float availableHeight,
+      MeasureMode heightMode);
+
+  bool hasMinContentMeasureFunc() const noexcept {
+    return minContentMeasureFunc_ != nullptr;
+  }
+
+  YGSize measureMinContent(
+      float availableWidth,
+      MeasureMode widthMode,
+      float availableHeight,
+      MeasureMode heightMode);
+
+  FloatOptional getMinContentWidth() const noexcept {
+    return minContentWidth_;
+  }
+
+  FloatOptional getMinContentHeight() const noexcept {
+    return minContentHeight_;
+  }
+
+  bool hasBaselineFunc() const noexcept {
+    return baselineFunc_ != nullptr;
+  }
+
+  float baseline(float width, float height) const;
+
+  float dimensionWithMargin(FlexDirection axis, float widthSize);
+
+  bool isLayoutDimensionDefined(FlexDirection axis);
+
+  /**
+   * Whether the node has a "definite length" along the given axis.
+   * https://www.w3.org/TR/css-sizing-3/#definite
+   */
+  inline bool hasDefiniteLength(Dimension dimension, float ownerSize) {
+    auto usedValue = getProcessedDimension(dimension).resolve(ownerSize);
+    return usedValue.isDefined() && usedValue.unwrap() >= 0.0f;
+  }
+
+  bool hasErrata(Errata errata) const {
+    return config_->hasErrata(errata);
+  }
+
+  bool hasContentsChildren() const {
+    return contentsChildrenCount_ != 0;
+  }
+
+  YGDirtiedFunc getDirtiedFunc() const {
+    return dirtiedFunc_;
+  }
+
+  // For Performance reasons passing as reference.
+  Style& style() {
+    return style_;
+  }
+
+  const Style& style() const {
+    return style_;
+  }
+
+  // For Performance reasons passing as reference.
+  LayoutResults& getLayout() {
+    return layout_;
+  }
+
+  const LayoutResults& getLayout() const {
+    return layout_;
+  }
+
+  size_t getLineIndex() const {
+    return lineIndex_;
+  }
+
+  bool isReferenceBaseline() const {
+    return isReferenceBaseline_;
+  }
+
+  // returns the Node that owns this Node. An owner is used to identify
+  // the YogaTree that a Node belongs to. This method will return the parent
+  // of the Node when a Node only belongs to one YogaTree or nullptr when
+  // the Node is shared between two or more YogaTrees.
+  Node* getOwner() const {
+    return owner_;
+  }
+
+  const std::vector<Node*>& getChildren() const {
+    return children_;
+  }
+
+  Node* getChild(size_t index) const {
+    return children_.at(index);
+  }
+
+  size_t getChildCount() const {
+    return children_.size();
+  }
+
+  LayoutableChildren getLayoutChildren() const {
+    return LayoutableChildren(this);
+  }
+
+  size_t getLayoutChildCount() const {
+    if (contentsChildrenCount_ == 0) {
+      return children_.size();
+    } else {
+      size_t count = 0;
+      for (auto iter = getLayoutChildren().begin();
+           iter != getLayoutChildren().end();
+           iter++) {
+        count++;
+      }
+      return count;
+    }
+  }
+
+  const Config* getConfig() const {
+    return config_;
+  }
+
+  bool isDirty() const {
+    return isDirty_;
+  }
+
+  Style::SizeLength getProcessedDimension(Dimension dimension) const {
+    return processedDimensions_[static_cast<size_t>(dimension)];
+  }
+
+  FloatOptional getResolvedDimension(
+      Direction direction,
+      Dimension dimension,
+      float referenceLength,
+      float ownerWidth) const {
+    FloatOptional value =
+        getProcessedDimension(dimension).resolve(referenceLength);
+    if (style_.boxSizing() == BoxSizing::BorderBox) {
+      return value;
+    }
+
+    FloatOptional dimensionPaddingAndBorder =
+        FloatOptional{style_.computePaddingAndBorderForDimension(
+            direction, dimension, ownerWidth)};
+
+    return value +
+        (dimensionPaddingAndBorder.isDefined() ? dimensionPaddingAndBorder
+                                               : FloatOptional{0.0});
+  }
+
+  // Setters
+
+  void setContext(void* context) {
+    context_ = context;
+  }
+
+  void setAlwaysFormsContainingBlock(bool alwaysFormsContainingBlock) {
+    alwaysFormsContainingBlock_ = alwaysFormsContainingBlock;
+  }
+
+  void setHasNewLayout(bool hasNewLayout) {
+    hasNewLayout_ = hasNewLayout;
+  }
+
+  void setNodeType(NodeType nodeType) {
+    nodeType_ = nodeType;
+  }
+
+  void setMeasureFunc(YGMeasureFunc measureFunc);
+
+  void setMinContentMeasureFunc(YGMinContentMeasureFunc minContentMeasureFunc) {
+    minContentMeasureFunc_ = minContentMeasureFunc;
+  }
+
+  void setMinContentWidth(FloatOptional minContentWidth) noexcept {
+    minContentWidth_ = minContentWidth;
+  }
+
+  void setMinContentHeight(FloatOptional minContentHeight) noexcept {
+    minContentHeight_ = minContentHeight;
+  }
+
+  void setBaselineFunc(YGBaselineFunc baseLineFunc) {
+    baselineFunc_ = baseLineFunc;
+  }
+
+  void setDirtiedFunc(YGDirtiedFunc dirtiedFunc) {
+    dirtiedFunc_ = dirtiedFunc;
+  }
+
+  void setStyle(const Style& style) {
+    style_ = style;
+  }
+
+  void setLayout(const LayoutResults& layout) {
+    layout_ = layout;
+  }
+
+  void setLineIndex(size_t lineIndex) {
+    lineIndex_ = lineIndex;
+  }
+
+  void setIsReferenceBaseline(bool isReferenceBaseline) {
+    isReferenceBaseline_ = isReferenceBaseline;
+  }
+
+  void setOwner(Node* owner) {
+    owner_ = owner;
+  }
+
+  // TODO: rvalue override for setChildren
+
+  void setConfig(Config* config);
+
+  void setDirty(bool isDirty);
+  void setChildren(const std::vector<Node*>& children);
+  void setLayoutLastOwnerDirection(Direction direction);
+  void setLayoutComputedFlexBasis(FloatOptional computedFlexBasis);
+  void setLayoutComputedFlexBasisGeneration(
+      uint32_t computedFlexBasisGeneration);
+  void setLayoutMeasuredDimension(float measuredDimension, Dimension dimension);
+  void setLayoutHadOverflow(bool hadOverflow);
+  void setLayoutDimension(float lengthValue, Dimension dimension);
+  void setLayoutDirection(Direction direction);
+  void setLayoutMargin(float margin, PhysicalEdge edge);
+  void setLayoutBorder(float border, PhysicalEdge edge);
+  void setLayoutPadding(float padding, PhysicalEdge edge);
+  void setLayoutPosition(float position, PhysicalEdge edge);
+  void setPosition(Direction direction, float ownerWidth, float ownerHeight);
+
+  // Other methods
+  Style::SizeLength processFlexBasis() const;
+  FloatOptional resolveFlexBasis(
+      Direction direction,
+      FlexDirection flexDirection,
+      float referenceLength,
+      float ownerWidth) const;
+  void processDimensions();
+  Direction resolveDirection(Direction ownerDirection);
+  void clearChildren();
+  /// Replaces the occurrences of oldChild with newChild
+  void replaceChild(Node* oldChild, Node* newChild);
+  void replaceChild(Node* child, size_t index);
+  void insertChild(Node* child, size_t index);
+  /// Removes the first occurrence of child
+  bool removeChild(Node* child);
+  void removeChild(size_t index);
+
+  void cloneChildrenIfNeeded();
+  void cloneContentsChildrenIfNeeded();
+  void markDirtyAndPropagate();
+  float resolveFlexGrow() const;
+  float resolveFlexShrink() const;
+  bool isNodeFlexible();
+  void reset();
+
+  float relativePosition(
+      FlexDirection axis,
+      Direction direction,
+      float axisSize) const;
+
+ private:
+  // Used to allow resetting the node
+  Node& operator=(Node&&) noexcept = default;
+
+  void useWebDefaults() {
+    style_.setFlexDirection(FlexDirection::Row);
+    style_.setAlignContent(Align::Stretch);
+  }
+
+  bool hasNewLayout_ : 1 = true;
+  bool isReferenceBaseline_ : 1 = false;
+  bool isDirty_ : 1 = true;
+  bool alwaysFormsContainingBlock_ : 1 = false;
+  NodeType nodeType_ : bitCount<NodeType>() = NodeType::Default;
+  void* context_ = nullptr;
+  YGMeasureFunc measureFunc_ = nullptr;
+  YGMinContentMeasureFunc minContentMeasureFunc_ = nullptr;
+  FloatOptional minContentWidth_{};
+  FloatOptional minContentHeight_{};
+  YGBaselineFunc baselineFunc_ = nullptr;
+  YGDirtiedFunc dirtiedFunc_ = nullptr;
+  Style style_;
+  LayoutResults layout_;
+  size_t lineIndex_ = 0;
+  size_t contentsChildrenCount_ = 0;
+  Node* owner_ = nullptr;
+  std::vector<Node*> children_;
+  const Config* config_;
+  std::array<Style::SizeLength, 2> processedDimensions_{
+      {StyleSizeLength::undefined(), StyleSizeLength::undefined()}};
+};
+
+inline Node* resolveRef(const YGNodeRef ref) {
+  return static_cast<Node*>(ref);
+}
+
+inline const Node* resolveRef(const YGNodeConstRef ref) {
+  return static_cast<const Node*>(ref);
+}
+
+} // namespace facebook::yoga

package/yoga/yoga/numeric/Comparison.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <concepts>
+
+#include <yoga/Yoga.h>
+
+namespace facebook::yoga {
+
+constexpr bool isUndefined(std::floating_point auto value) {
+  return value != value;
+}
+
+constexpr bool isDefined(std::floating_point auto value) {
+  return !isUndefined(value);
+}
+
+/**
+ * Constexpr version of `std::isinf` before C++ 23
+ */
+constexpr bool isinf(auto value) {
+  return value == +std::numeric_limits<decltype(value)>::infinity() ||
+      value == -std::numeric_limits<decltype(value)>::infinity();
+}
+
+constexpr auto maxOrDefined(
+    std::floating_point auto a,
+    std::floating_point auto b) {
+  if (yoga::isDefined(a) && yoga::isDefined(b)) {
+    return std::max(a, b);
+  }
+  return yoga::isUndefined(a) ? b : a;
+}
+
+constexpr auto minOrDefined(
+    std::floating_point auto a,
+    std::floating_point auto b) {
+  if (yoga::isDefined(a) && yoga::isDefined(b)) {
+    return std::min(a, b);
+  }
+
+  return yoga::isUndefined(a) ? b : a;
+}
+
+// Custom equality functions using a hardcoded epsilon of 0.0001f, or returning
+// true if both floats are NaN.
+inline bool inexactEquals(float a, float b) {
+  if (yoga::isDefined(a) && yoga::isDefined(b)) {
+    return std::abs(a - b) < 0.0001f;
+  }
+  return yoga::isUndefined(a) && yoga::isUndefined(b);
+}
+
+inline bool inexactEquals(double a, double b) {
+  if (yoga::isDefined(a) && yoga::isDefined(b)) {
+    return std::abs(a - b) < 0.0001;
+  }
+  return yoga::isUndefined(a) && yoga::isUndefined(b);
+}
+
+template <std::size_t Size, typename ElementT>
+bool inexactEquals(
+    const std::array<ElementT, Size>& val1,
+    const std::array<ElementT, Size>& val2) {
+  bool areEqual = true;
+  for (std::size_t i = 0; i < Size && areEqual; ++i) {
+    areEqual = inexactEquals(val1[i], val2[i]);
+  }
+  return areEqual;
+}
+
+} // namespace facebook::yoga

package/yoga/yoga/numeric/FloatOptional.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <yoga/numeric/Comparison.h>
+#include <limits>
+
+namespace facebook::yoga {
+
+struct FloatOptional {
+ private:
+  float value_ = std::numeric_limits<float>::quiet_NaN();
+
+ public:
+  explicit constexpr FloatOptional(float value) : value_(value) {}
+  constexpr FloatOptional() = default;
+
+  // returns the wrapped value, or a value x with YGIsUndefined(x) == true
+  constexpr float unwrap() const {
+    return value_;
+  }
+
+  constexpr float unwrapOrDefault(float defaultValue) const {
+    return isUndefined() ? defaultValue : value_;
+  }
+
+  constexpr bool isUndefined() const {
+    return yoga::isUndefined(value_);
+  }
+
+  constexpr bool isDefined() const {
+    return yoga::isDefined(value_);
+  }
+};
+
+// operators take FloatOptional by value, as it is a 32bit value
+
+constexpr bool operator==(FloatOptional lhs, FloatOptional rhs) {
+  return lhs.unwrap() == rhs.unwrap() ||
+      (lhs.isUndefined() && rhs.isUndefined());
+}
+
+constexpr bool operator==(FloatOptional lhs, float rhs) {
+  return lhs == FloatOptional{rhs};
+}
+
+constexpr bool operator==(float lhs, FloatOptional rhs) {
+  return rhs == lhs;
+}
+
+constexpr FloatOptional operator+(FloatOptional lhs, FloatOptional rhs) {
+  return FloatOptional{lhs.unwrap() + rhs.unwrap()};
+}
+
+constexpr bool operator>(FloatOptional lhs, FloatOptional rhs) {
+  return lhs.unwrap() > rhs.unwrap();
+}
+
+constexpr bool operator<(FloatOptional lhs, FloatOptional rhs) {
+  return lhs.unwrap() < rhs.unwrap();
+}
+
+constexpr bool operator>=(FloatOptional lhs, FloatOptional rhs) {
+  return lhs > rhs || lhs == rhs;
+}
+
+constexpr bool operator<=(FloatOptional lhs, FloatOptional rhs) {
+  return lhs < rhs || lhs == rhs;
+}
+
+constexpr FloatOptional maxOrDefined(FloatOptional lhs, FloatOptional rhs) {
+  return FloatOptional{yoga::maxOrDefined(lhs.unwrap(), rhs.unwrap())};
+}
+
+inline bool inexactEquals(FloatOptional lhs, FloatOptional rhs) {
+  return yoga::inexactEquals(lhs.unwrap(), rhs.unwrap());
+}
+
+} // namespace facebook::yoga

package/yoga/yoga/style/GridLine.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <cstdint>
+
+namespace facebook::yoga {
+
+// https://www.w3.org/TR/css-grid-1/#typedef-grid-row-start-grid-line
+enum class GridLineType : uint8_t {
+  Auto,
+  Integer,
+  Span,
+};
+
+struct GridLine {
+  GridLineType type{};
+  // Line position (1, 2, -1, -2, etc)
+  int32_t integer{};
+
+  constexpr static GridLine auto_() {
+    return GridLine{.type = GridLineType::Auto, .integer = 0};
+  }
+
+  constexpr static GridLine fromInteger(int32_t value) {
+    return GridLine{.type = GridLineType::Integer, .integer = value};
+  }
+
+  constexpr static GridLine span(int32_t value) {
+    return GridLine{.type = GridLineType::Span, .integer = value};
+  }
+
+  constexpr bool isAuto() const {
+    return type == GridLineType::Auto;
+  }
+
+  constexpr bool isInteger() const {
+    return type == GridLineType::Integer;
+  }
+
+  constexpr bool isSpan() const {
+    return type == GridLineType::Span;
+  }
+
+  bool operator==(const GridLine& other) const = default;
+};
+
+} // namespace facebook::yoga

package/yoga/yoga/style/GridStyle.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <memory>
+
+#include <yoga/style/GridLine.h>
+#include <yoga/style/GridTrack.h>
+
+namespace facebook::yoga {
+
+/**
+ * The CSS Grid properties of a single node.
+ */
+struct GridStyle {
+  // Grid container properties
+  GridTrackList templateColumns{};
+  GridTrackList templateRows{};
+  GridTrackList autoColumns{};
+  GridTrackList autoRows{};
+
+  // Grid item properties
+  GridLine columnStart{};
+  GridLine columnEnd{};
+  GridLine rowStart{};
+  GridLine rowEnd{};
+
+  bool operator==(const GridStyle& other) const = default;
+};
+
+/**
+ * Storage for a GridStyle which stays empty until the first grid property is
+ * set.
+ */
+class GridStyleStorage {
+ public:
+  GridStyleStorage() = default;
+  GridStyleStorage(GridStyleStorage&&) noexcept = default;
+  GridStyleStorage& operator=(GridStyleStorage&&) noexcept = default;
+
+  GridStyleStorage(const GridStyleStorage& other) {
+    *this = other;
+  }
+
+  GridStyleStorage& operator=(const GridStyleStorage& other) {
+    grid_ = other.grid_ == nullptr ? nullptr
+                                   : std::make_unique<GridStyle>(*other.grid_);
+    return *this;
+  }
+
+  const GridStyle& get() const {
+    return grid_ == nullptr ? defaults() : *grid_;
+  }
+
+  GridStyle& ensure() {
+    if (grid_ == nullptr) {
+      grid_ = std::make_unique<GridStyle>();
+    }
+    return *grid_;
+  }
+
+  bool operator==(const GridStyleStorage& other) const {
+    return grid_ == other.grid_ || get() == other.get();
+  }
+
+ private:
+  static const GridStyle& defaults() {
+    static const GridStyle kDefaults{};
+    return kDefaults;
+  }
+
+  std::unique_ptr<GridStyle> grid_{};
+};
+
+} // namespace facebook::yoga