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

package/src/yoga/core/layoutResults.ts

@@ -0,0 +1,167 @@
+// SPDX-License-Identifier: MIT
+// Derived from Yoga. See THIRD_PARTY_NOTICES.md.
+
+// Port of yoga/node/LayoutResults.h and yoga/node/CachedMeasurement.h.
+
+import { Dimension, Direction } from "../generated/YGEnums.ts";
+import type { FlexLine } from "./flexLine.ts";
+import { PhysicalEdge, SizingMode } from "./helpers.ts";
+import { isUndefined } from "./numeric.ts";
+
+export class CachedMeasurement {
+  availableWidth = -1;
+  availableHeight = -1;
+  widthSizingMode: SizingMode = SizingMode.MaxContent;
+  heightSizingMode: SizingMode = SizingMode.MaxContent;
+
+  computedWidth = -1;
+  computedHeight = -1;
+
+  equals(measurement: CachedMeasurement): boolean {
+    let isEqual =
+      this.widthSizingMode === measurement.widthSizingMode &&
+      this.heightSizingMode === measurement.heightSizingMode;
+
+    if (!isUndefined(this.availableWidth) || !isUndefined(measurement.availableWidth)) {
+      isEqual = isEqual && this.availableWidth === measurement.availableWidth;
+    }
+    if (!isUndefined(this.availableHeight) || !isUndefined(measurement.availableHeight)) {
+      isEqual = isEqual && this.availableHeight === measurement.availableHeight;
+    }
+    if (!isUndefined(this.computedWidth) || !isUndefined(measurement.computedWidth)) {
+      isEqual = isEqual && this.computedWidth === measurement.computedWidth;
+    }
+    if (!isUndefined(this.computedHeight) || !isUndefined(measurement.computedHeight)) {
+      isEqual = isEqual && this.computedHeight === measurement.computedHeight;
+    }
+
+    return isEqual;
+  }
+}
+
+export class LayoutResults {
+  // This value was chosen based on empirical data:
+  // 98% of analyzed layouts require less than 8 entries.
+  static readonly MaxCachedMeasurements = 8;
+
+  computedFlexBasisGeneration = 0;
+  computedFlexBasis = NaN;
+
+  // Per-flex-item floor along the main axis derived from CSS Flexbox §4.5
+  // automatic minimum sizing. NaN means "no auto-min applies."
+  computedAutoMinMainSize = NaN;
+
+  // Instead of recomputing the entire layout every single time, we cache some
+  // information to break early when nothing changed
+  generationCount = 0;
+  configVersion = 0;
+  lastOwnerDirection: Direction = Direction.Inherit;
+
+  nextCachedMeasurementsIndex = 0;
+  // Entries are allocated lazily on first write; reads are gated by
+  // nextCachedMeasurementsIndex so unwritten slots are never observed.
+  cachedMeasurements: CachedMeasurement[] = [];
+
+  // Pixel-grid bookkeeping: true when this node or any descendant had a
+  // position/dimension write (or text-rounding change) since the last
+  // rounding pass. Together with the last-seen absolute offsets this lets
+  // roundLayoutResultsToPixelGrid skip subtrees whose inputs are unchanged —
+  // the pass is deterministic, so skipping is output-identical.
+  roundingDirty = true;
+  roundedAbsLeft = NaN;
+  roundedAbsTop = NaN;
+  roundedScale = NaN;
+
+  cachedLayout: CachedMeasurement = new CachedMeasurement();
+
+  // Lazily-created scratch state reused by flex layout passes. Keeping this
+  // per node makes recursive and cross-tree layouts independent while
+  // removing per-line arrays and objects from repeat layouts.
+  flexLine: FlexLine | null = null;
+  flexLineStarts: number[] | null = null;
+
+  private direction_: Direction = Direction.Inherit;
+  private hadOverflow_ = false;
+
+  // All float layout state lives in one packed numeric array. Writes are
+  // kept as native JavaScript numbers to avoid repeated float32 coercion.
+  // Layout: [0-1] dimensions, [2-3] measuredDimensions, [4-5] rawDimensions,
+  // [6-9] position, [10-13] margin, [14-17] border, [18-21] padding.
+  private values_: number[] = initialLayoutValues();
+
+  direction(): Direction {
+    return this.direction_;
+  }
+
+  setDirection(direction: Direction): void {
+    this.direction_ = direction;
+  }
+
+  hadOverflow(): boolean {
+    return this.hadOverflow_;
+  }
+
+  setHadOverflow(hadOverflow: boolean): void {
+    this.hadOverflow_ = hadOverflow;
+  }
+
+  dimension(axis: Dimension): number {
+    return this.values_[axis]!;
+  }
+
+  setDimension(axis: Dimension, dimension: number): void {
+    this.values_[axis] = dimension;
+  }
+
+  measuredDimension(axis: Dimension): number {
+    return this.values_[2 + axis]!;
+  }
+
+  rawDimension(axis: Dimension): number {
+    return this.values_[4 + axis]!;
+  }
+
+  setMeasuredDimension(axis: Dimension, dimension: number): void {
+    this.values_[2 + axis] = dimension;
+  }
+
+  setRawDimension(axis: Dimension, dimension: number): void {
+    this.values_[4 + axis] = dimension;
+  }
+
+  position(physicalEdge: PhysicalEdge): number {
+    return this.values_[6 + physicalEdge]!;
+  }
+
+  setPosition(physicalEdge: PhysicalEdge, dimension: number): void {
+    this.values_[6 + physicalEdge] = dimension;
+  }
+
+  margin(physicalEdge: PhysicalEdge): number {
+    return this.values_[10 + physicalEdge]!;
+  }
+
+  setMargin(physicalEdge: PhysicalEdge, dimension: number): void {
+    this.values_[10 + physicalEdge] = dimension;
+  }
+
+  border(physicalEdge: PhysicalEdge): number {
+    return this.values_[14 + physicalEdge]!;
+  }
+
+  setBorder(physicalEdge: PhysicalEdge, dimension: number): void {
+    this.values_[14 + physicalEdge] = dimension;
+  }
+
+  padding(physicalEdge: PhysicalEdge): number {
+    return this.values_[18 + physicalEdge]!;
+  }
+
+  setPadding(physicalEdge: PhysicalEdge, dimension: number): void {
+    this.values_[18 + physicalEdge] = dimension;
+  }
+}
+
+function initialLayoutValues(): number[] {
+  return [NaN, NaN, NaN, NaN, NaN, NaN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+}