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

package/src/yoga/core/config.ts

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: MIT
+// Derived from Yoga. See THIRD_PARTY_NOTICES.md.
+
+// Port of yoga/config/Config.h and yoga/config/Config.cpp.
+
+import { Errata, ExperimentalFeature } from "../generated/YGEnums.ts";
+
+// Whether moving a node from an old to new config should dirty previously
+// calculated layout results.
+export function configUpdateInvalidatesLayout(oldConfig: Config, newConfig: Config): boolean {
+  return (
+    oldConfig.getErrata() !== newConfig.getErrata() ||
+    oldConfig.getEnabledExperiments() !== newConfig.getEnabledExperiments() ||
+    oldConfig.getPointScaleFactor() !== newConfig.getPointScaleFactor() ||
+    oldConfig.useWebDefaults() !== newConfig.useWebDefaults()
+  );
+}
+
+export class Config {
+  private useWebDefaults_ = false;
+  private version_ = 0;
+  private experimentalFeatures_ = 0;
+  private errata_: Errata = Errata.MinSizeUndefinedInsteadOfAuto;
+  private pointScaleFactor_ = 1.0;
+
+  setUseWebDefaults(useWebDefaults: boolean): void {
+    this.useWebDefaults_ = useWebDefaults;
+  }
+
+  useWebDefaults(): boolean {
+    return this.useWebDefaults_;
+  }
+
+  setExperimentalFeatureEnabled(feature: ExperimentalFeature, enabled: boolean): void {
+    if (this.isExperimentalFeatureEnabled(feature) !== enabled) {
+      this.experimentalFeatures_ = enabled
+        ? this.experimentalFeatures_ | (1 << feature)
+        : this.experimentalFeatures_ & ~(1 << feature);
+      this.version_++;
+    }
+  }
+
+  isExperimentalFeatureEnabled(feature: ExperimentalFeature): boolean {
+    return (this.experimentalFeatures_ & (1 << feature)) !== 0;
+  }
+
+  getEnabledExperiments(): number {
+    return this.experimentalFeatures_;
+  }
+
+  setErrata(errata: Errata): void {
+    if (this.errata_ !== errata) {
+      this.errata_ = errata;
+      this.version_++;
+    }
+  }
+
+  addErrata(errata: Errata): void {
+    if (!this.hasErrata(errata)) {
+      this.errata_ |= errata;
+      this.version_++;
+    }
+  }
+
+  removeErrata(errata: Errata): void {
+    if (this.hasErrata(errata)) {
+      this.errata_ &= ~errata;
+      this.version_++;
+    }
+  }
+
+  getErrata(): Errata {
+    return this.errata_;
+  }
+
+  hasErrata(errata: Errata): boolean {
+    return (this.errata_ & errata) !== Errata.None;
+  }
+
+  setPointScaleFactor(pointScaleFactor: number): void {
+    const value = pointScaleFactor;
+    if (this.pointScaleFactor_ !== value) {
+      this.pointScaleFactor_ = value;
+      this.version_++;
+    }
+  }
+
+  getPointScaleFactor(): number {
+    return this.pointScaleFactor_;
+  }
+
+  getVersion(): number {
+    return this.version_;
+  }
+}
+
+let defaultConfig: Config | null = null;
+
+export function getDefaultConfig(): Config {
+  if (defaultConfig === null) {
+    defaultConfig = new Config();
+  }
+  return defaultConfig;
+}

package/src/yoga/core/flexLine.ts

@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: MIT
+// Derived from Yoga. See THIRD_PARTY_NOTICES.md.
+
+// Port of yoga/algorithm/FlexLine.h and yoga/algorithm/FlexLine.cpp.
+//
+// The C++ version advances a shared LayoutableChildren iterator; here the
+// caller materializes the layout children into an array once and this function
+// receives the start index, returning the index of the first child of the next
+// line alongside the line itself.
+
+import { Direction, Display, PositionType, Wrap } from "../generated/YGEnums.ts";
+import { boundAxisWithinMinAndMax, resolveDirection } from "./helpers.ts";
+import type { Node } from "./node.ts";
+
+export interface FlexLineRunningLayout {
+  // Total flex grow factors of flex items which are to be laid in the current
+  // line. This is decremented as free space is distributed.
+  totalFlexGrowFactors: number;
+
+  // Total flex shrink factors of flex items which are to be laid in the
+  // current line. This is decremented as free space is distributed.
+  totalFlexShrinkScaledFactors: number;
+
+  // The amount of available space within inner dimensions of the line which
+  // may still be distributed.
+  remainingFreeSpace: number;
+
+  // The size of the mainDim for the row after considering size, padding,
+  // margin and border of flex items. This is used to calculate maxLineDim
+  // after going through all the rows to decide on the main axis size of owner.
+  mainDim: number;
+
+  // The size of the crossDim for the row after considering size, padding,
+  // margin and border of flex items. Used for calculating containers
+  // crossSize.
+  crossDim: number;
+}
+
+export interface FlexLine {
+  // List of children which are part of the line flow. This means they are not
+  // positioned absolutely, or with `display: "none"`, and do not overflow the
+  // available dimensions.
+  itemsInFlow: Node[];
+
+  // Accumulation of the dimensions and margin of all the children on the
+  // current line. This will be used in order to either set the dimensions of
+  // the node if none already exist or to compute the remaining space left for
+  // the flexible children.
+  sizeConsumed: number;
+
+  // Number of edges along the line flow with an auto margin.
+  numberOfAutoMargins: number;
+
+  // Index into the layout-children array of the first child of the next line.
+  endIndex: number;
+
+  // Layout information about the line computed in steps after line-breaking
+  layout: FlexLineRunningLayout;
+}
+
+// Calculates where a line starting at a given index should break, returning
+// information about the collective children on the line.
+//
+// This function assumes that all the children of node have their
+// computedFlexBasis properly computed (to do this use the
+// computeFlexBasisForChildren function).
+export function calculateFlexLine(
+  node: Node,
+  ownerDirection: Direction,
+  ownerWidth: number,
+  mainAxisOwnerSize: number,
+  availableInnerWidth: number,
+  availableInnerMainDim: number,
+  layoutChildren: readonly Node[],
+  startIndex: number,
+  lineCount: number,
+  flexLine: FlexLine,
+): void {
+  const itemsInFlow = flexLine.itemsInFlow;
+  itemsInFlow.length = 0;
+
+  let sizeConsumed = 0;
+  let totalFlexGrowFactors = 0;
+  let totalFlexShrinkScaledFactors = 0;
+  let numberOfAutoMargins = 0;
+  let firstElementInLine: Node | null = null;
+
+  let sizeConsumedIncludingMinConstraint = 0;
+  const direction = node.resolveDirection(ownerDirection);
+  const mainAxis = resolveDirection(node.style.flexDirection(), direction);
+  const isNodeFlexWrap = node.style.flexWrap() !== Wrap.NoWrap;
+  const gap = node.style.computeGapForAxis(mainAxis, availableInnerMainDim);
+
+  let index = startIndex;
+  // Add items to the current line until it's full or we run out of items.
+  for (; index < layoutChildren.length; index++) {
+    const child = layoutChildren[index]!;
+    if (
+      child.style.display() === Display.None ||
+      child.style.positionType() === PositionType.Absolute
+    ) {
+      continue;
+    }
+
+    if (firstElementInLine === null) {
+      firstElementInLine = child;
+    }
+
+    if (child.style.flexStartMarginIsAuto(mainAxis, ownerDirection)) {
+      numberOfAutoMargins++;
+    }
+    if (child.style.flexEndMarginIsAuto(mainAxis, ownerDirection)) {
+      numberOfAutoMargins++;
+    }
+
+    child.lineIndex = lineCount;
+    const childMarginMainAxis = child.style.computeMarginForAxis(mainAxis, availableInnerWidth);
+    const childLeadingGapMainAxis = child === firstElementInLine ? 0 : gap;
+    const flexBasisWithMinAndMaxConstraints = boundAxisWithinMinAndMax(
+      child,
+      direction,
+      mainAxis,
+      child.layout.computedFlexBasis,
+      mainAxisOwnerSize,
+      ownerWidth,
+    );
+
+    // If this is a multi-line flow and this item pushes us over the available
+    // size, we've hit the end of the current line. Break out of the loop and
+    // lay out the current line.
+    if (
+      sizeConsumedIncludingMinConstraint +
+        flexBasisWithMinAndMaxConstraints +
+        childMarginMainAxis +
+        childLeadingGapMainAxis >
+        availableInnerMainDim &&
+      isNodeFlexWrap &&
+      itemsInFlow.length > 0
+    ) {
+      break;
+    }
+
+    sizeConsumedIncludingMinConstraint +=
+      flexBasisWithMinAndMaxConstraints + childMarginMainAxis + childLeadingGapMainAxis;
+    sizeConsumed +=
+      flexBasisWithMinAndMaxConstraints + childMarginMainAxis + childLeadingGapMainAxis;
+
+    if (child.isNodeFlexible()) {
+      totalFlexGrowFactors += child.resolveFlexGrow();
+
+      // Unlike the grow factor, the shrink factor is scaled relative to the
+      // child dimension.
+      totalFlexShrinkScaledFactors += -child.resolveFlexShrink() * child.layout.computedFlexBasis;
+    }
+
+    itemsInFlow.push(child);
+  }
+
+  // The total flex factor needs to be floored to 1.
+  if (totalFlexGrowFactors > 0 && totalFlexGrowFactors < 1) {
+    totalFlexGrowFactors = 1;
+  }
+
+  // The total flex shrink factor needs to be floored to 1.
+  if (totalFlexShrinkScaledFactors > 0 && totalFlexShrinkScaledFactors < 1) {
+    totalFlexShrinkScaledFactors = 1;
+  }
+
+  flexLine.sizeConsumed = sizeConsumed;
+  flexLine.numberOfAutoMargins = numberOfAutoMargins;
+  flexLine.endIndex = index;
+  flexLine.layout.totalFlexGrowFactors = totalFlexGrowFactors;
+  flexLine.layout.totalFlexShrinkScaledFactors = totalFlexShrinkScaledFactors;
+  flexLine.layout.remainingFreeSpace = 0;
+  flexLine.layout.mainDim = 0;
+  flexLine.layout.crossDim = 0;
+}

package/src/yoga/core/helpers.ts

@@ -0,0 +1,293 @@
+// SPDX-License-Identifier: MIT
+// Derived from Yoga. See THIRD_PARTY_NOTICES.md.
+
+// Port of yoga/algorithm/FlexDirection.h, yoga/algorithm/Align.h,
+// yoga/algorithm/SizingMode.h, yoga/algorithm/TrailingPosition.h and
+// yoga/algorithm/BoundAxis.h, plus the internal PhysicalEdge enum.
+
+import {
+  Align,
+  Dimension,
+  Direction,
+  Display,
+  FlexDirection,
+  Justify,
+  MeasureMode,
+} from "../generated/YGEnums.ts";
+import type { Node } from "./node.ts";
+import { maxOrDefined } from "./numeric.ts";
+
+export const PhysicalEdge = {
+  Left: 0,
+  Top: 1,
+  Right: 2,
+  Bottom: 3,
+} as const;
+export type PhysicalEdge = (typeof PhysicalEdge)[keyof typeof PhysicalEdge];
+
+// Port of yoga/algorithm/SizingMode.h
+export const SizingMode = {
+  StretchFit: 0,
+  MaxContent: 1,
+  FitContent: 2,
+} as const;
+export type SizingMode = (typeof SizingMode)[keyof typeof SizingMode];
+
+export function measureMode(mode: SizingMode): MeasureMode {
+  switch (mode) {
+    case SizingMode.StretchFit:
+      return MeasureMode.Exactly;
+    case SizingMode.MaxContent:
+      return MeasureMode.Undefined;
+    case SizingMode.FitContent:
+      return MeasureMode.AtMost;
+  }
+}
+
+export function sizingMode(mode: MeasureMode): SizingMode {
+  switch (mode) {
+    case MeasureMode.Exactly:
+      return SizingMode.StretchFit;
+    case MeasureMode.Undefined:
+      return SizingMode.MaxContent;
+    case MeasureMode.AtMost:
+      return SizingMode.FitContent;
+  }
+}
+
+// Port of yoga/algorithm/FlexDirection.h
+
+export function isRow(flexDirection: FlexDirection): boolean {
+  return (flexDirection & FlexDirection.Row) !== 0;
+}
+
+export function isColumn(flexDirection: FlexDirection): boolean {
+  return (flexDirection & FlexDirection.Row) === 0;
+}
+
+export function resolveDirection(
+  flexDirection: FlexDirection,
+  direction: Direction,
+): FlexDirection {
+  if (direction === Direction.RTL) {
+    if (flexDirection === FlexDirection.Row) {
+      return FlexDirection.RowReverse;
+    } else if (flexDirection === FlexDirection.RowReverse) {
+      return FlexDirection.Row;
+    }
+  }
+
+  return flexDirection;
+}
+
+export function resolveCrossDirection(
+  flexDirection: FlexDirection,
+  direction: Direction,
+): FlexDirection {
+  return isColumn(flexDirection)
+    ? resolveDirection(FlexDirection.Row, direction)
+    : FlexDirection.Column;
+}
+
+// Table-lookup forms of the per-axis switches, indexed by FlexDirection
+// (Column, ColumnReverse, Row, RowReverse).
+const FLEX_START_EDGE = [
+  PhysicalEdge.Top,
+  PhysicalEdge.Bottom,
+  PhysicalEdge.Left,
+  PhysicalEdge.Right,
+] as const;
+
+const FLEX_END_EDGE = [
+  PhysicalEdge.Bottom,
+  PhysicalEdge.Top,
+  PhysicalEdge.Right,
+  PhysicalEdge.Left,
+] as const;
+
+const DIMENSION_OF_AXIS = [
+  Dimension.Height,
+  Dimension.Height,
+  Dimension.Width,
+  Dimension.Width,
+] as const;
+
+export function flexStartEdge(flexDirection: FlexDirection): PhysicalEdge {
+  return FLEX_START_EDGE[flexDirection];
+}
+
+export function flexEndEdge(flexDirection: FlexDirection): PhysicalEdge {
+  return FLEX_END_EDGE[flexDirection];
+}
+
+export function inlineStartEdge(flexDirection: FlexDirection, direction: Direction): PhysicalEdge {
+  if (isRow(flexDirection)) {
+    return direction === Direction.RTL ? PhysicalEdge.Right : PhysicalEdge.Left;
+  }
+
+  return PhysicalEdge.Top;
+}
+
+export function inlineEndEdge(flexDirection: FlexDirection, direction: Direction): PhysicalEdge {
+  if (isRow(flexDirection)) {
+    return direction === Direction.RTL ? PhysicalEdge.Left : PhysicalEdge.Right;
+  }
+
+  return PhysicalEdge.Bottom;
+}
+
+export function dimension(flexDirection: FlexDirection): Dimension {
+  return DIMENSION_OF_AXIS[flexDirection];
+}
+
+// Port of yoga/algorithm/Align.h
+
+export function resolveChildAlignment(node: Node, child: Node): Align {
+  const align =
+    child.style.alignSelf() === Align.Auto ? node.style.alignItems() : child.style.alignSelf();
+
+  if (
+    node.style.display() === Display.Flex &&
+    align === Align.Baseline &&
+    isColumn(node.style.flexDirection())
+  ) {
+    return Align.FlexStart;
+  }
+
+  return align;
+}
+
+export function resolveChildJustification(node: Node, child: Node): Justify {
+  return child.style.justifySelf() === Justify.Auto
+    ? node.style.justifyItems()
+    : child.style.justifySelf();
+}
+
+/**
+ * Fallback alignment to use on overflow
+ * https://www.w3.org/TR/css-align-3/#distribution-values
+ */
+export function fallbackAlignment(align: Align): Align {
+  switch (align) {
+    // Fallback to flex-start
+    case Align.SpaceBetween:
+    case Align.Stretch:
+      return Align.FlexStart;
+
+    // Fallback to safe center. TODO (T208209388): This should be aligned to
+    // Start instead of FlexStart (for row-reverse containers)
+    case Align.SpaceAround:
+    case Align.SpaceEvenly:
+      return Align.FlexStart;
+    default:
+      return align;
+  }
+}
+
+export function fallbackJustification(align: Justify): Justify {
+  switch (align) {
+    // Fallback to flex-start
+    case Justify.SpaceBetween:
+      return Justify.FlexStart;
+
+    // Fallback to safe center. TODO (T208209388): This should be aligned to
+    // Start instead of FlexStart (for row-reverse containers)
+    case Justify.SpaceAround:
+    case Justify.SpaceEvenly:
+      return Justify.FlexStart;
+    default:
+      return align;
+  }
+}
+
+// Port of yoga/algorithm/BoundAxis.h
+
+export function paddingAndBorderForAxis(
+  node: Node,
+  axis: FlexDirection,
+  direction: Direction,
+  widthSize: number,
+): number {
+  if (!node.style.hasPaddingOrBorder()) {
+    return 0;
+  }
+  return (
+    node.style.computeInlineStartPaddingAndBorder(axis, direction, widthSize) +
+    node.style.computeInlineEndPaddingAndBorder(axis, direction, widthSize)
+  );
+}
+
+export function boundAxisWithinMinAndMax(
+  node: Node,
+  direction: Direction,
+  axis: FlexDirection,
+  value: number,
+  axisSize: number,
+  widthSize: number,
+): number {
+  let min = NaN;
+  let max = NaN;
+
+  if (isColumn(axis)) {
+    min = node.style.resolvedMinDimension(direction, Dimension.Height, axisSize, widthSize);
+    max = node.style.resolvedMaxDimension(direction, Dimension.Height, axisSize, widthSize);
+  } else if (isRow(axis)) {
+    min = node.style.resolvedMinDimension(direction, Dimension.Width, axisSize, widthSize);
+    max = node.style.resolvedMaxDimension(direction, Dimension.Width, axisSize, widthSize);
+  }
+
+  if (max >= 0 && value > max) {
+    return max;
+  }
+
+  if (min >= 0 && value < min) {
+    return min;
+  }
+
+  return value;
+}
+
+// Like boundAxisWithinMinAndMax but also ensures that the value doesn't
+// go below the padding and border amount.
+export function boundAxis(
+  node: Node,
+  axis: FlexDirection,
+  direction: Direction,
+  value: number,
+  axisSize: number,
+  widthSize: number,
+): number {
+  return maxOrDefined(
+    boundAxisWithinMinAndMax(node, direction, axis, value, axisSize, widthSize),
+    paddingAndBorderForAxis(node, axis, direction, widthSize),
+  );
+}
+
+// Port of yoga/algorithm/TrailingPosition.h
+
+// Given an offset to an edge, returns the offset to the opposite edge on the
+// same axis. This assumes that the width/height of both nodes is determined at
+// this point.
+export function getPositionOfOppositeEdge(
+  position: number,
+  axis: FlexDirection,
+  containingNode: Node,
+  node: Node,
+): number {
+  return (
+    containingNode.layout.measuredDimension(dimension(axis)) -
+    node.layout.measuredDimension(dimension(axis)) -
+    position
+  );
+}
+
+export function setChildTrailingPosition(node: Node, child: Node, axis: FlexDirection): void {
+  child.setLayoutPosition(
+    getPositionOfOppositeEdge(child.layout.position(flexStartEdge(axis)), axis, node, child),
+    flexEndEdge(axis),
+  );
+}
+
+export function needsTrailingPosition(axis: FlexDirection): boolean {
+  return axis === FlexDirection.RowReverse || axis === FlexDirection.ColumnReverse;
+}