@alchemy.run/sigil 0.0.0-alpha.1 → 0.0.0-alpha.2

package/src/yoga/core/absoluteLayout.ts

@@ -0,0 +1,626 @@
+// SPDX-License-Identifier: MIT
+// Derived from Yoga. See THIRD_PARTY_NOTICES.md.
+
+// Port of yoga/algorithm/AbsoluteLayout.cpp. Grid-specific branches are kept
+// where they read from style, but Display.Grid is not otherwise supported.
+
+import {
+  Align,
+  Dimension,
+  Direction,
+  Display,
+  Errata,
+  FlexDirection,
+  Justify,
+  PositionType,
+  Wrap,
+} from "../generated/YGEnums.ts";
+import {
+  type LayoutData,
+  LayoutPassReason,
+  calculateLayoutInternal,
+  cleanupContentsNodesRecursively,
+} from "./calculateLayout.ts";
+import {
+  PhysicalEdge,
+  SizingMode,
+  boundAxis,
+  dimension,
+  flexEndEdge,
+  flexStartEdge,
+  getPositionOfOppositeEdge,
+  inlineStartEdge,
+  isRow,
+  needsTrailingPosition,
+  resolveChildAlignment,
+  resolveChildJustification,
+  resolveCrossDirection,
+  resolveDirection,
+  setChildTrailingPosition,
+} from "./helpers.ts";
+import type { Node } from "./node.ts";
+import { isDefined, isUndefined } from "./numeric.ts";
+
+function setFlexStartLayoutPosition(
+  parent: Node,
+  child: Node,
+  direction: Direction,
+  axis: FlexDirection,
+  containingBlockWidth: number,
+): void {
+  let position =
+    child.style.computeFlexStartMargin(axis, direction, containingBlockWidth) +
+    parent.layout.border(flexStartEdge(axis));
+
+  // https://www.w3.org/TR/css-grid-1/#abspos
+  // absolute positioned grid items are positioned relative to the padding edge
+  // of the grid container
+  if (
+    !child.hasErrata(Errata.AbsolutePositionWithoutInsetsExcludesPadding) &&
+    parent.style.display() !== Display.Grid
+  ) {
+    position += parent.layout.padding(flexStartEdge(axis));
+  }
+
+  child.setLayoutPosition(position, flexStartEdge(axis));
+}
+
+function setFlexEndLayoutPosition(
+  parent: Node,
+  child: Node,
+  direction: Direction,
+  axis: FlexDirection,
+  containingBlockWidth: number,
+): void {
+  let flexEndPosition =
+    parent.layout.border(flexEndEdge(axis)) +
+    child.style.computeFlexEndMargin(axis, direction, containingBlockWidth);
+
+  // https://www.w3.org/TR/css-grid-1/#abspos
+  // absolute positioned grid items are positioned relative to the padding edge
+  // of the grid container
+  if (
+    !child.hasErrata(Errata.AbsolutePositionWithoutInsetsExcludesPadding) &&
+    parent.style.display() !== Display.Grid
+  ) {
+    flexEndPosition += parent.layout.padding(flexEndEdge(axis));
+  }
+
+  child.setLayoutPosition(
+    getPositionOfOppositeEdge(flexEndPosition, axis, parent, child),
+    flexStartEdge(axis),
+  );
+}
+
+function setCenterLayoutPosition(
+  parent: Node,
+  child: Node,
+  direction: Direction,
+  axis: FlexDirection,
+  containingBlockWidth: number,
+): void {
+  let parentContentBoxSize =
+    parent.layout.measuredDimension(dimension(axis)) -
+    parent.layout.border(flexStartEdge(axis)) -
+    parent.layout.border(flexEndEdge(axis));
+
+  // https://www.w3.org/TR/css-grid-1/#abspos
+  // absolute positioned grid items are positioned relative to the padding edge
+  // of the grid container
+  if (
+    !child.hasErrata(Errata.AbsolutePositionWithoutInsetsExcludesPadding) &&
+    parent.style.display() !== Display.Grid
+  ) {
+    parentContentBoxSize -= parent.layout.padding(flexStartEdge(axis));
+    parentContentBoxSize -= parent.layout.padding(flexEndEdge(axis));
+  }
+
+  const childOuterSize =
+    child.layout.measuredDimension(dimension(axis)) +
+    child.style.computeMarginForAxis(axis, containingBlockWidth);
+
+  let position =
+    (parentContentBoxSize - childOuterSize) / 2.0 +
+    parent.layout.border(flexStartEdge(axis)) +
+    child.style.computeFlexStartMargin(axis, direction, containingBlockWidth);
+
+  // https://www.w3.org/TR/css-grid-1/#abspos
+  // absolute positioned grid items are positioned relative to the padding edge
+  // of the grid container
+  if (
+    !child.hasErrata(Errata.AbsolutePositionWithoutInsetsExcludesPadding) &&
+    parent.style.display() !== Display.Grid
+  ) {
+    position += parent.layout.padding(flexStartEdge(axis));
+  }
+
+  child.setLayoutPosition(position, flexStartEdge(axis));
+}
+
+function justifyAbsoluteChild(
+  parent: Node,
+  child: Node,
+  direction: Direction,
+  mainAxis: FlexDirection,
+  containingBlockWidth: number,
+): void {
+  const justify =
+    parent.style.display() === Display.Grid
+      ? resolveChildJustification(parent, child)
+      : parent.style.justifyContent();
+  switch (justify) {
+    case Justify.Start:
+    case Justify.Auto:
+    case Justify.Stretch:
+    case Justify.FlexStart:
+    case Justify.SpaceBetween:
+      setFlexStartLayoutPosition(parent, child, direction, mainAxis, containingBlockWidth);
+      break;
+    case Justify.End:
+    case Justify.FlexEnd:
+      setFlexEndLayoutPosition(parent, child, direction, mainAxis, containingBlockWidth);
+      break;
+    case Justify.Center:
+    case Justify.SpaceAround:
+    case Justify.SpaceEvenly:
+      setCenterLayoutPosition(parent, child, direction, mainAxis, containingBlockWidth);
+      break;
+  }
+}
+
+function alignAbsoluteChild(
+  parent: Node,
+  child: Node,
+  direction: Direction,
+  crossAxis: FlexDirection,
+  containingBlockWidth: number,
+): void {
+  let itemAlign = resolveChildAlignment(parent, child);
+  const parentWrap = parent.style.flexWrap();
+  if (parentWrap === Wrap.WrapReverse) {
+    if (itemAlign === Align.FlexEnd) {
+      itemAlign = Align.FlexStart;
+    } else if (itemAlign !== Align.Center) {
+      itemAlign = Align.FlexEnd;
+    }
+  }
+
+  switch (itemAlign) {
+    case Align.Start:
+    case Align.Auto:
+    case Align.FlexStart:
+    case Align.Baseline:
+    case Align.SpaceAround:
+    case Align.SpaceBetween:
+    case Align.Stretch:
+    case Align.SpaceEvenly:
+      setFlexStartLayoutPosition(parent, child, direction, crossAxis, containingBlockWidth);
+      break;
+    case Align.End:
+    case Align.FlexEnd:
+      setFlexEndLayoutPosition(parent, child, direction, crossAxis, containingBlockWidth);
+      break;
+    case Align.Center:
+      setCenterLayoutPosition(parent, child, direction, crossAxis, containingBlockWidth);
+      break;
+  }
+}
+
+/*
+ * Absolutely positioned nodes do not participate in flex layout and thus their
+ * positions can be determined independently from the rest of their siblings.
+ * For each axis there are essentially two cases:
+ *
+ * 1) The node has insets defined. In this case we can just use these to
+ *    determine the position of the node.
+ * 2) The node does not have insets defined. In this case we look at the style
+ *    of the parent to position the node. Things like justify content and
+ *    align content will move absolute children around. If none of these
+ *    special properties are defined, the child is positioned at the start
+ *    (defined by flex direction) of the leading flex line.
+ *
+ * This function does that positioning for the given axis. The spec has more
+ * information on this topic: https://www.w3.org/TR/css-flexbox-1/#abspos-items
+ */
+function positionAbsoluteChild(
+  containingNode: Node,
+  parent: Node,
+  child: Node,
+  direction: Direction,
+  axis: FlexDirection,
+  isMainAxis: boolean,
+  containingBlockWidth: number,
+  containingBlockHeight: number,
+): void {
+  const isAxisRow = isRow(axis);
+  const containingBlockSize = isAxisRow ? containingBlockWidth : containingBlockHeight;
+
+  // The inline-start position takes priority over the end position in the case
+  // that they are both set and the node has a fixed width. Thus we only have 2
+  // cases here: if inline-start is defined and if inline-end is defined.
+  //
+  // Despite checking inline-start to honor prioritization of insets, we write
+  // to the flex-start edge because this algorithm works by positioning on the
+  // flex-start edge and then filling in the flex-end direction at the end if
+  // necessary.
+  if (
+    child.style.isInlineStartPositionDefined(axis, direction) &&
+    !child.style.isInlineStartPositionAuto(axis, direction)
+  ) {
+    const positionRelativeToInlineStart =
+      child.style.computeInlineStartPosition(axis, direction, containingBlockSize) +
+      containingNode.style.computeInlineStartBorder(axis, direction) +
+      child.style.computeInlineStartMargin(axis, direction, containingBlockSize);
+    const positionRelativeToFlexStart =
+      inlineStartEdge(axis, direction) !== flexStartEdge(axis)
+        ? getPositionOfOppositeEdge(positionRelativeToInlineStart, axis, containingNode, child)
+        : positionRelativeToInlineStart;
+
+    child.setLayoutPosition(positionRelativeToFlexStart, flexStartEdge(axis));
+  } else if (
+    child.style.isInlineEndPositionDefined(axis, direction) &&
+    !child.style.isInlineEndPositionAuto(axis, direction)
+  ) {
+    const positionRelativeToInlineStart =
+      containingNode.layout.measuredDimension(dimension(axis)) -
+      child.layout.measuredDimension(dimension(axis)) -
+      containingNode.style.computeInlineEndBorder(axis, direction) -
+      child.style.computeInlineEndMargin(axis, direction, containingBlockSize) -
+      child.style.computeInlineEndPosition(axis, direction, containingBlockSize);
+    const positionRelativeToFlexStart =
+      inlineStartEdge(axis, direction) !== flexStartEdge(axis)
+        ? getPositionOfOppositeEdge(positionRelativeToInlineStart, axis, containingNode, child)
+        : positionRelativeToInlineStart;
+
+    child.setLayoutPosition(positionRelativeToFlexStart, flexStartEdge(axis));
+  } else if (isMainAxis) {
+    justifyAbsoluteChild(parent, child, direction, axis, containingBlockWidth);
+  } else {
+    alignAbsoluteChild(parent, child, direction, axis, containingBlockWidth);
+  }
+}
+
+export function layoutAbsoluteChild(
+  containingNode: Node,
+  node: Node,
+  child: Node,
+  containingBlockWidth: number,
+  containingBlockHeight: number,
+  widthMode: SizingMode,
+  direction: Direction,
+  layoutMarkerData: LayoutData,
+  depth: number,
+  generationCount: number,
+): void {
+  // For grid containers, use inline (Row) and block (Column) axes for
+  // positioning, since grid alignment properties (justify-self, align-self)
+  // operate on inline/block axes, not main/cross axes based on flex-direction.
+  const mainAxis =
+    node.style.display() === Display.Grid
+      ? resolveDirection(FlexDirection.Row, direction)
+      : resolveDirection(node.style.flexDirection(), direction);
+  const crossAxis =
+    node.style.display() === Display.Grid
+      ? FlexDirection.Column
+      : resolveCrossDirection(mainAxis, direction);
+  const isMainAxisRow = isRow(mainAxis);
+
+  let childWidth = NaN;
+  let childHeight = NaN;
+  let childWidthSizingMode: SizingMode = SizingMode.MaxContent;
+  let childHeightSizingMode: SizingMode = SizingMode.MaxContent;
+
+  const marginRow = child.style.computeMarginForAxis(FlexDirection.Row, containingBlockWidth);
+  const marginColumn = child.style.computeMarginForAxis(FlexDirection.Column, containingBlockWidth);
+
+  if (child.hasDefiniteLength(Dimension.Width, containingBlockWidth)) {
+    childWidth =
+      child.getResolvedDimension(
+        direction,
+        Dimension.Width,
+        containingBlockWidth,
+        containingBlockWidth,
+      ) + marginRow;
+  } else {
+    // If the child doesn't have a specified width, compute the width based on
+    // the left/right offsets if they're defined.
+    if (
+      child.style.isFlexStartPositionDefined(FlexDirection.Row, direction) &&
+      child.style.isFlexEndPositionDefined(FlexDirection.Row, direction) &&
+      !child.style.isFlexStartPositionAuto(FlexDirection.Row, direction) &&
+      !child.style.isFlexEndPositionAuto(FlexDirection.Row, direction)
+    ) {
+      childWidth =
+        containingNode.layout.measuredDimension(Dimension.Width) -
+        (containingNode.style.computeFlexStartBorder(FlexDirection.Row, direction) +
+          containingNode.style.computeFlexEndBorder(FlexDirection.Row, direction)) -
+        (child.style.computeFlexStartPosition(FlexDirection.Row, direction, containingBlockWidth) +
+          child.style.computeFlexEndPosition(FlexDirection.Row, direction, containingBlockWidth));
+      childWidth = boundAxis(
+        child,
+        FlexDirection.Row,
+        direction,
+        childWidth,
+        containingBlockWidth,
+        containingBlockWidth,
+      );
+    }
+  }
+
+  if (child.hasDefiniteLength(Dimension.Height, containingBlockHeight)) {
+    childHeight =
+      child.getResolvedDimension(
+        direction,
+        Dimension.Height,
+        containingBlockHeight,
+        containingBlockWidth,
+      ) + marginColumn;
+  } else {
+    // If the child doesn't have a specified height, compute the height based
+    // on the top/bottom offsets if they're defined.
+    if (
+      child.style.isFlexStartPositionDefined(FlexDirection.Column, direction) &&
+      child.style.isFlexEndPositionDefined(FlexDirection.Column, direction) &&
+      !child.style.isFlexStartPositionAuto(FlexDirection.Column, direction) &&
+      !child.style.isFlexEndPositionAuto(FlexDirection.Column, direction)
+    ) {
+      childHeight =
+        containingNode.layout.measuredDimension(Dimension.Height) -
+        (containingNode.style.computeFlexStartBorder(FlexDirection.Column, direction) +
+          containingNode.style.computeFlexEndBorder(FlexDirection.Column, direction)) -
+        (child.style.computeFlexStartPosition(
+          FlexDirection.Column,
+          direction,
+          containingBlockHeight,
+        ) +
+          child.style.computeFlexEndPosition(
+            FlexDirection.Column,
+            direction,
+            containingBlockHeight,
+          ));
+      childHeight = boundAxis(
+        child,
+        FlexDirection.Column,
+        direction,
+        childHeight,
+        containingBlockHeight,
+        containingBlockWidth,
+      );
+    }
+  }
+
+  // Exactly one dimension needs to be defined for us to be able to do aspect
+  // ratio calculation. One dimension being the anchor and the other being
+  // flexible.
+  const childStyle = child.style;
+  if (isUndefined(childWidth) !== isUndefined(childHeight)) {
+    if (isDefined(childStyle.aspectRatio())) {
+      if (isUndefined(childWidth)) {
+        childWidth = marginRow + (childHeight - marginColumn) * childStyle.aspectRatio();
+      } else if (isUndefined(childHeight)) {
+        childHeight = marginColumn + (childWidth - marginRow) / childStyle.aspectRatio();
+      }
+    }
+  }
+
+  // If we're still missing one or the other dimension, measure the content.
+  if (isUndefined(childWidth) || isUndefined(childHeight)) {
+    childWidthSizingMode = isUndefined(childWidth) ? SizingMode.MaxContent : SizingMode.StretchFit;
+    childHeightSizingMode = isUndefined(childHeight)
+      ? SizingMode.MaxContent
+      : SizingMode.StretchFit;
+
+    // If the size of the owner is defined then try to constrain the absolute
+    // child to that size as well. This allows text within the absolute child
+    // to wrap to the size of its owner. This is the same behavior as many
+    // browsers implement.
+    if (
+      !isMainAxisRow &&
+      isUndefined(childWidth) &&
+      widthMode !== SizingMode.MaxContent &&
+      isDefined(containingBlockWidth) &&
+      containingBlockWidth > 0
+    ) {
+      childWidth = containingBlockWidth;
+      childWidthSizingMode = SizingMode.FitContent;
+    }
+
+    calculateLayoutInternal(
+      child,
+      childWidth,
+      childHeight,
+      direction,
+      childWidthSizingMode,
+      childHeightSizingMode,
+      containingBlockWidth,
+      containingBlockHeight,
+      false,
+      LayoutPassReason.AbsMeasureChild,
+      layoutMarkerData,
+      depth,
+      generationCount,
+    );
+    childWidth =
+      child.layout.measuredDimension(Dimension.Width) +
+      child.style.computeMarginForAxis(FlexDirection.Row, containingBlockWidth);
+    childHeight =
+      child.layout.measuredDimension(Dimension.Height) +
+      child.style.computeMarginForAxis(FlexDirection.Column, containingBlockWidth);
+  }
+
+  calculateLayoutInternal(
+    child,
+    childWidth,
+    childHeight,
+    direction,
+    SizingMode.StretchFit,
+    SizingMode.StretchFit,
+    containingBlockWidth,
+    containingBlockHeight,
+    true,
+    LayoutPassReason.AbsLayout,
+    layoutMarkerData,
+    depth,
+    generationCount,
+  );
+
+  positionAbsoluteChild(
+    containingNode,
+    node,
+    child,
+    direction,
+    mainAxis,
+    true /*isMainAxis*/,
+    containingBlockWidth,
+    containingBlockHeight,
+  );
+  positionAbsoluteChild(
+    containingNode,
+    node,
+    child,
+    direction,
+    crossAxis,
+    false /*isMainAxis*/,
+    containingBlockWidth,
+    containingBlockHeight,
+  );
+}
+
+export function layoutAbsoluteDescendants(
+  containingNode: Node,
+  currentNode: Node,
+  widthSizingMode: SizingMode,
+  currentNodeDirection: Direction,
+  layoutMarkerData: LayoutData,
+  currentDepth: number,
+  generationCount: number,
+  currentNodeLeftOffsetFromContainingBlock: number,
+  currentNodeTopOffsetFromContainingBlock: number,
+  containingNodeAvailableInnerWidth: number,
+  containingNodeAvailableInnerHeight: number,
+): boolean {
+  let hasNewLayout = false;
+  for (const child of currentNode.getLayoutChildren()) {
+    if (child.style.display() === Display.None) {
+      continue;
+    } else if (child.style.positionType() === PositionType.Absolute) {
+      const absoluteErrata = currentNode.hasErrata(Errata.AbsolutePercentAgainstInnerSize);
+      const containingBlockWidth = absoluteErrata
+        ? containingNodeAvailableInnerWidth
+        : containingNode.layout.measuredDimension(Dimension.Width) -
+          containingNode.style.computeBorderForAxis(FlexDirection.Row);
+      const containingBlockHeight = absoluteErrata
+        ? containingNodeAvailableInnerHeight
+        : containingNode.layout.measuredDimension(Dimension.Height) -
+          containingNode.style.computeBorderForAxis(FlexDirection.Column);
+
+      layoutAbsoluteChild(
+        containingNode,
+        currentNode,
+        child,
+        containingBlockWidth,
+        containingBlockHeight,
+        widthSizingMode,
+        currentNodeDirection,
+        layoutMarkerData,
+        currentDepth,
+        generationCount,
+      );
+
+      hasNewLayout = hasNewLayout || child.hasNewLayout_;
+
+      /*
+       * At this point the child has its position set but only on its the
+       * parent's flexStart edge. Additionally, this position should be
+       * interpreted relative to the containing block of the child if it had
+       * insets defined. So we need to adjust the position by subtracting the
+       * the parents offset from the containing block. However, getting that
+       * offset is complicated since the two nodes can have different main/cross
+       * axes.
+       */
+      const parentMainAxis = resolveDirection(
+        currentNode.style.flexDirection(),
+        currentNodeDirection,
+      );
+      const parentCrossAxis = resolveCrossDirection(parentMainAxis, currentNodeDirection);
+
+      if (needsTrailingPosition(parentMainAxis)) {
+        const mainInsetsDefined = isRow(parentMainAxis)
+          ? child.style.horizontalInsetsDefined()
+          : child.style.verticalInsetsDefined();
+        setChildTrailingPosition(
+          mainInsetsDefined ? containingNode : currentNode,
+          child,
+          parentMainAxis,
+        );
+      }
+      if (needsTrailingPosition(parentCrossAxis)) {
+        const crossInsetsDefined = isRow(parentCrossAxis)
+          ? child.style.horizontalInsetsDefined()
+          : child.style.verticalInsetsDefined();
+        setChildTrailingPosition(
+          crossInsetsDefined ? containingNode : currentNode,
+          child,
+          parentCrossAxis,
+        );
+      }
+
+      /*
+       * At this point we know the left and top physical edges of the child are
+       * set with positions that are relative to the containing block if insets
+       * are defined
+       */
+      const childLeftPosition = child.layout.position(PhysicalEdge.Left);
+      const childTopPosition = child.layout.position(PhysicalEdge.Top);
+
+      const childLeftOffsetFromParent = child.style.horizontalInsetsDefined()
+        ? childLeftPosition - currentNodeLeftOffsetFromContainingBlock
+        : childLeftPosition;
+      const childTopOffsetFromParent = child.style.verticalInsetsDefined()
+        ? childTopPosition - currentNodeTopOffsetFromContainingBlock
+        : childTopPosition;
+
+      child.setLayoutPosition(childLeftOffsetFromParent, PhysicalEdge.Left);
+      child.setLayoutPosition(childTopOffsetFromParent, PhysicalEdge.Top);
+    } else if (
+      child.style.positionType() === PositionType.Static &&
+      !child.alwaysFormsContainingBlock
+    ) {
+      // We may write new layout results for absolute descendants of "child"
+      // which are positioned relative to the current containing block instead
+      // of their parent. "child" may not be dirty, or have new constraints, so
+      // absolute positioning may be the first time during this layout pass
+      // that we need to mutate these descendents. Make sure the path of nodes
+      // to them is mutable before positioning.
+      child.cloneChildrenIfNeeded();
+      const childDirection = child.resolveDirection(currentNodeDirection);
+      // By now all descendants of the containing block that are not absolute
+      // will have their positions set for left and top.
+      const childLeftOffsetFromContainingBlock =
+        currentNodeLeftOffsetFromContainingBlock + child.layout.position(PhysicalEdge.Left);
+      const childTopOffsetFromContainingBlock =
+        currentNodeTopOffsetFromContainingBlock + child.layout.position(PhysicalEdge.Top);
+
+      hasNewLayout =
+        layoutAbsoluteDescendants(
+          containingNode,
+          child,
+          widthSizingMode,
+          childDirection,
+          layoutMarkerData,
+          currentDepth + 1,
+          generationCount,
+          childLeftOffsetFromContainingBlock,
+          childTopOffsetFromContainingBlock,
+          containingNodeAvailableInnerWidth,
+          containingNodeAvailableInnerHeight,
+        ) || hasNewLayout;
+
+      cleanupContentsNodesRecursively(child, /* didPerformLayout */ hasNewLayout);
+      if (hasNewLayout) {
+        child.hasNewLayout_ = hasNewLayout;
+      }
+    }
+  }
+  return hasNewLayout;
+}

package/src/yoga/core/baseline.ts

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT
+// Derived from Yoga. See THIRD_PARTY_NOTICES.md.
+
+// Port of yoga/algorithm/Baseline.cpp.
+
+import { Align, Dimension, PositionType } from "../generated/YGEnums.ts";
+import { PhysicalEdge, isColumn, resolveChildAlignment } from "./helpers.ts";
+import type { Node } from "./node.ts";
+
+export function calculateBaseline(node: Node): number {
+  if (node.hasBaselineFunc()) {
+    const baseline = node.baseline(
+      node.layout.measuredDimension(Dimension.Width),
+      node.layout.measuredDimension(Dimension.Height),
+    );
+
+    if (Number.isNaN(baseline)) {
+      throw new Error("Expect custom baseline function to not return NaN");
+    }
+    return baseline;
+  }
+
+  let baselineChild: Node | null = null;
+  for (const child of node.getLayoutChildren()) {
+    if (child.lineIndex > 0) {
+      break;
+    }
+    if (child.style.positionType() === PositionType.Absolute) {
+      continue;
+    }
+    if (resolveChildAlignment(node, child) === Align.Baseline || child.isReferenceBaseline_) {
+      baselineChild = child;
+      break;
+    }
+
+    if (baselineChild === null) {
+      baselineChild = child;
+    }
+  }
+
+  if (baselineChild === null) {
+    return node.layout.measuredDimension(Dimension.Height);
+  }
+
+  const baseline = calculateBaseline(baselineChild);
+  return baseline + baselineChild.layout.position(PhysicalEdge.Top);
+}
+
+export function isBaselineLayout(node: Node): boolean {
+  if (isColumn(node.style.flexDirection())) {
+    return false;
+  }
+  if (node.style.alignItems() === Align.Baseline) {
+    return true;
+  }
+  for (const child of node.getLayoutChildren()) {
+    if (
+      child.style.positionType() !== PositionType.Absolute &&
+      child.style.alignSelf() === Align.Baseline
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}