@pilates/core 1.1.0 → 2.0.1

package/dist/algorithm/spineless/field-id-pool.js

@@ -0,0 +1,35 @@
+/**
+ * Monotonic integer ID allocator for Spineless `Field` objects.
+ * Phase 15I indexes the runtime's typed-array storage by field.id.
+ *
+ * IDs are never recycled — Fields are interned per (node, name) and
+ * live as long as their node. The max id is the live-field high-water
+ * mark, matching LayoutPool's accepted tradeoff.
+ *
+ * @internal
+ */
+let _nextFieldId = 0;
+/** Allocate a fresh unique integer id for a Field. */
+export function allocateFieldId() {
+    return _nextFieldId++;
+}
+/** Current id count — the exclusive upper bound of allocated ids.
+ *  Runtime typed arrays size to at least this. @internal */
+export function fieldIdCount() {
+    return _nextFieldId;
+}
+/** Reset for tests. @internal
+ *
+ * WARNING: Only safe to call when no live `Field` objects exist
+ * anywhere — the `FIELD_REGISTRY` WeakMap in `grammar.ts` is NOT
+ * cleared, so any `Field` retained across this call still holds
+ * its old id. Newly-allocated fields will then collide with retained
+ * ids, aliasing entries in the runtime's typed-array storage. The
+ * standard test harness creates fresh `Node`s per test, so retained
+ * cross-test references are the only way to hit this; don't introduce
+ * them.
+ */
+export function _resetFieldIdsForTesting() {
+    _nextFieldId = 0;
+}
+//# sourceMappingURL=field-id-pool.js.map

package/dist/algorithm/spineless/field-id-pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-id-pool.js","sourceRoot":"","sources":["../../../src/algorithm/spineless/field-id-pool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,IAAI,YAAY,GAAG,CAAC,CAAC;AAErB,sDAAsD;AACtD,MAAM,UAAU,eAAe;IAC7B,OAAO,YAAY,EAAE,CAAC;AACxB,CAAC;AAED;4DAC4D;AAC5D,MAAM,UAAU,YAAY;IAC1B,OAAO,YAAY,CAAC;AACtB,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,wBAAwB;IACtC,YAAY,GAAG,CAAC,CAAC;AACnB,CAAC"}

package/dist/algorithm/spineless/flex-grammar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flex-grammar.d.ts","sourceRoot":"","sources":["../../../src/algorithm/spineless/flex-grammar.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"flex-grammar.d.ts","sourceRoot":"","sources":["../../../src/algorithm/spineless/flex-grammar.ts"],"names":[],"mappings":"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"}

package/dist/algorithm/spineless/flex-grammar.js

@@ -395,6 +395,43 @@ function makeEmitter(ctx) {
         }
         return f;
     }
+    /** Fold `minWidth`/`minHeight` (default 0) or `maxWidth`/`maxHeight`
+     *  (default `undefined` → ∞). Returns a constant when at default;
+     *  emits a leaf Field (via `minMaxInput`) otherwise. */
+    function foldMinMax(n, prop) {
+        const isMax = prop === 'maxWidth' || prop === 'maxHeight';
+        const raw = n.style[prop];
+        // Default sentinels MUST match nodeSig exactly (layout.ts):
+        //   minWidth/minHeight default === 0
+        //   maxWidth/maxHeight default === undefined
+        if (isMax ? raw === undefined : raw === 0) {
+            return { kind: 'const', value: isMax ? Number.POSITIVE_INFINITY : 0 };
+        }
+        return { kind: 'field', field: minMaxInput(n, prop) };
+    }
+    /** Fold one margin `edge` (default 0). Returns a constant when margin
+     *  is 0; emits a leaf Field (via `marginInput`) otherwise. */
+    function foldMargin(n, edge) {
+        // Default sentinel MUST match nodeSig exactly (layout.ts):
+        //   margin[edge] default === 0
+        if ((n.style.margin[edge] ?? 0) === 0)
+            return { kind: 'const', value: 0 };
+        return { kind: 'field', field: marginInput(n, edge) };
+    }
+    /** Read a FoldedInput inside a compute callback. */
+    function readFolded(fi, read) {
+        return fi.kind === 'field' ? read(fi.field) : fi.value;
+    }
+    /** Collect only the Field entries from a FoldedInput list. */
+    function foldedDeps(fis) {
+        const deps = [];
+        for (const fi of fis) {
+            if (fi.kind === 'field')
+                deps.push(fi.field);
+        }
+        return deps;
+    }
+    // ──────────────────────────────────────────────────────────────────────
     function visit(node, parent, indexInParent, priorSiblings) {
         const width = field(node, 'width');
         const height = field(node, 'height');
@@ -448,6 +485,7 @@ function makeEmitter(ctx) {
         const mainPosField = parentDirection === 'column' ? top : left;
         const crossPosField = parentDirection === 'column' ? left : top;
         const mainSizeName = parentDirection === 'column' ? 'height' : 'width';
+        const mainPosName = parentDirection === 'column' ? 'top' : 'left';
         // Spacing inputs for this child. Both the parent's padding and
         // this child's own margin are modelled as leaf input Fields (see
         // `paddingInput` / `marginInput`) — one per [top,right,bottom,
@@ -465,9 +503,42 @@ function makeEmitter(ctx) {
         const padMainEndF = parent === null ? null : paddingInput(parent, mainEndEdge(parentDirection));
         const padCrossStartF = parent === null ? null : paddingInput(parent, crossStartEdge(parentDirection));
         const padCrossEndF = parent === null ? null : paddingInput(parent, crossEndEdge(parentDirection));
-        const myMarginMainStartF = parent === null ? null : marginInput(node, mainStartEdge(parentDirection));
-        const myMarginCrossStartF = parent === null ? null : marginInput(node, crossStartEdge(parentDirection));
-        const myMarginCrossEndF = parent === null ? null : marginInput(node, crossEndEdge(parentDirection));
+        // Phase 17: margin fields are resolved lazily at each rule site via
+        // foldMargin() (fold-eligible rules) or marginInput() (always-needed).
+        // Pre-compute edge indices once to avoid repeating edge-name calls.
+        const mainStartEdgeIdx = parent === null ? -1 : mainStartEdge(parentDirection);
+        const crossStartEdgeIdx = parent === null ? -1 : crossStartEdge(parentDirection);
+        const crossEndEdgeIdx = parent === null ? -1 : crossEndEdge(parentDirection);
+        // Rules that always require the full tracked Field (e.g. stretch
+        // crossSizeField, flex-end/center crossPos, reverse cumulative-sum)
+        // use these pre-resolved fields so the idempotent marginInput is called
+        // at most once per edge.
+        // NOTE: calling marginInput here forces Field creation for these edges
+        // regardless of whether they end up in a fold path. This is acceptable
+        // because the rules that read them (stretch/flex-end/center/reverse) are
+        // not fold-eligible — they always need tracked incremental propagation.
+        // For nodes on fully fold-eligible paths (flex-start, no-stretch, no-
+        // reverse), the Field is created if the code-path reaches it below;
+        // the fold-eligible rules that invoke foldMargin() bypass this and
+        // create no Field when margin is at default.
+        let myMarginMainStartF = null;
+        let myMarginCrossStartF = null;
+        let myMarginCrossEndF = null;
+        function getMarginMainStart() {
+            if (myMarginMainStartF === null)
+                myMarginMainStartF = marginInput(node, mainStartEdgeIdx);
+            return myMarginMainStartF;
+        }
+        function getMarginCrossStart() {
+            if (myMarginCrossStartF === null)
+                myMarginCrossStartF = marginInput(node, crossStartEdgeIdx);
+            return myMarginCrossStartF;
+        }
+        function getMarginCrossEnd() {
+            if (myMarginCrossEndF === null)
+                myMarginCrossEndF = marginInput(node, crossEndEdgeIdx);
+            return myMarginCrossEndF;
+        }
         // Alignment for this child: justify-content lives on the parent,
         // applies along the main axis once per line. align-items lives
         // on the parent; align-self overrides per child (with 'auto'
@@ -492,24 +563,29 @@ function makeEmitter(ctx) {
         const crossKey = parentDirection === 'column' ? 'width' : 'height';
         const crossIsContentAuto = typeof node.style[crossKey] !== 'number' && !aspectDerivable(node, crossKey);
         const crossSizeInput = preferredSizeInput(node, crossKey, 'cross', parent);
-        const minCrossInput = minMaxInput(node, crossKey === 'width' ? 'minWidth' : 'minHeight');
-        const maxCrossInput = minMaxInput(node, crossKey === 'width' ? 'maxWidth' : 'maxHeight');
+        // Phase 17: fold min/max cross inputs when at default (0 / undefined→∞).
+        const fMinCross = foldMinMax(node, crossKey === 'width' ? 'minWidth' : 'minHeight');
+        const fMaxCross = foldMinMax(node, crossKey === 'width' ? 'maxWidth' : 'maxHeight');
         if (crossIsContentAuto && parent !== null && align === 'stretch') {
+            // Stretch: resize to fill the parent's inner cross minus margins.
+            // The margins cannot be folded here (they appear in a subtraction
+            // expression), so use the always-needed field accessors.
+            const mcs = getMarginCrossStart();
+            const mce = getMarginCrossEnd();
             const parentCrossF = field(parent, crossKey);
             grammar.set(crossSizeField, {
                 deps: [
                     parentCrossF,
                     padCrossStartF,
                     padCrossEndF,
-                    myMarginCrossStartF,
-                    myMarginCrossEndF,
-                    minCrossInput,
-                    maxCrossInput,
+                    mcs,
+                    mce,
+                    ...foldedDeps([fMinCross, fMaxCross]),
                 ],
                 compute: (read) => {
                     const innerCross = Math.max(0, read(parentCrossF) - read(padCrossStartF) - read(padCrossEndF));
-                    const lineInner = innerCross - read(myMarginCrossStartF) - read(myMarginCrossEndF);
-                    return clampMinMax(Math.max(0, lineInner), read(minCrossInput), read(maxCrossInput));
+                    const lineInner = innerCross - read(mcs) - read(mce);
+                    return clampMinMax(Math.max(0, lineInner), readFolded(fMinCross, read), readFolded(fMaxCross, read));
                 },
             });
         }
@@ -522,13 +598,10 @@ function makeEmitter(ctx) {
             });
         }
         else {
+            // Phase 17: build deps only from non-default inputs.
             grammar.set(crossSizeField, {
-                deps: [
-                    crossSizeInput,
-                    minCrossInput,
-                    maxCrossInput,
-                ],
-                compute: (read) => clampMinMax(read(crossSizeInput), read(minCrossInput), read(maxCrossInput)),
+                deps: [crossSizeInput, ...foldedDeps([fMinCross, fMaxCross])],
+                compute: (read) => clampMinMax(read(crossSizeInput), readFolded(fMinCross, read), readFolded(fMaxCross, read)),
             });
         }
         // When the parent has flex-wrap='wrap', all three position fields
@@ -670,8 +743,9 @@ function makeEmitter(ctx) {
             // never consults it — so the root's main size is its preferred
             // size directly, no `flexBasis` short-circuit.
             const mainInput = preferredSizeInput(node, mainSizeName, 'main', parent);
-            const minMainInput = minMaxInput(node, mainSizeName === 'width' ? 'minWidth' : 'minHeight');
-            const maxMainInput = minMaxInput(node, mainSizeName === 'width' ? 'maxWidth' : 'maxHeight');
+            // Phase 17: fold min/max main inputs when at default (0 / undefined→∞).
+            const fMinMain = foldMinMax(node, mainSizeName === 'width' ? 'minWidth' : 'minHeight');
+            const fMaxMain = foldMinMax(node, mainSizeName === 'width' ? 'maxWidth' : 'maxHeight');
             if (parent === null) {
                 if (rootAxisIsBareZero(node, mainSizeName)) {
                     // `'auto'` root, no `available` → bare 0, unclamped.
@@ -681,28 +755,38 @@ function makeEmitter(ctx) {
                     });
                 }
                 else {
+                    // Phase 17: deps only include non-default min/max.
+                    grammar.set(mainSizeField, {
+                        deps: [mainInput, ...foldedDeps([fMinMain, fMaxMain])],
+                        compute: (read) => clampMinMax(read(mainInput), readFolded(fMinMain, read), readFolded(fMaxMain, read)),
+                    });
+                }
+            }
+            else {
+                // Phase 17: flexBasis 'auto' is folded — when flexBasis === 'auto',
+                // resolveBasisFromRead degenerates to read(mainInput). nodeSig already
+                // captures typeof s.flexBasis (the 'auto' vs numeric boundary), so a
+                // change from 'auto' to a numeric basis triggers a full rebuild.
+                const flexBasisIsAuto = node.style.flexBasis === 'auto';
+                if (flexBasisIsAuto) {
+                    // Degenerate form: basis auto → just use mainInput (no flexBasisInput field).
+                    grammar.set(mainSizeField, {
+                        deps: [mainInput, ...foldedDeps([fMinMain, fMaxMain])],
+                        compute: (read) => clampMinMax(read(mainInput), readFolded(fMinMain, read), readFolded(fMaxMain, read)),
+                    });
+                }
+                else {
+                    const flexBasisInput = styleSizeInput(node, 'flexBasis');
                     grammar.set(mainSizeField, {
                         deps: [
+                            flexBasisInput,
                             mainInput,
-                            minMainInput,
-                            maxMainInput,
+                            ...foldedDeps([fMinMain, fMaxMain]),
                         ],
-                        compute: (read) => clampMinMax(read(mainInput), read(minMainInput), read(maxMainInput)),
+                        compute: (read) => clampMinMax(resolveBasisFromRead(read, flexBasisInput, mainInput), readFolded(fMinMain, read), readFolded(fMaxMain, read)),
                     });
                 }
             }
-            else {
-                const flexBasisInput = styleSizeInput(node, 'flexBasis');
-                grammar.set(mainSizeField, {
-                    deps: [
-                        flexBasisInput,
-                        mainInput,
-                        minMainInput,
-                        maxMainInput,
-                    ],
-                    compute: (read) => clampMinMax(resolveBasisFromRead(read, flexBasisInput, mainInput), read(minMainInput), read(maxMainInput)),
-                });
-            }
         }
         else {
             // Flex distribution. Capture the in-flow siblings + this
@@ -815,9 +899,11 @@ function makeEmitter(ctx) {
                     });
                 }
                 else {
+                    // Phase 17: fold myMarginMainStart when at default (0).
+                    const fMyMarginMainStart = foldMargin(node, mainStartEdgeIdx);
                     grammar.set(mainPosField, {
-                        deps: [padMainStartF, myMarginMainStartF],
-                        compute: (read) => read(padMainStartF) + read(myMarginMainStartF),
+                        deps: [padMainStartF, ...foldedDeps([fMyMarginMainStart])],
+                        compute: (read) => read(padMainStartF) + readFolded(fMyMarginMainStart, read),
                     });
                 }
             }
@@ -840,25 +926,63 @@ function makeEmitter(ctx) {
                     compute: (read) => read(parentMainDist).positions[myIndexCapture],
                 });
             }
+            else if (!parentReverse) {
+                // Phase 16: linear recurrence. This child's main position is the
+                // immediate predecessor's position + its box + one gap. O(1) deps
+                // regardless of sibling count (was O(N) cumulative-sum). Unrolls
+                // to the same total — see the Phase 16 design doc.
+                // Note: only applies to forward directions; reverse directions use
+                // the cumulative-sum below because applyReverseMainPos overwrites
+                // each sibling's mainPosField with a reflected value, breaking the
+                // chain (the predecessor's field holds its reflected position, not
+                // the forward cursor this recurrence relies on).
+                const prevSibling = priorSiblings[priorSiblings.length - 1];
+                const prevMainPos = field(prevSibling, mainPosName);
+                const prevMainSize = field(prevSibling, mainSizeName);
+                const mainEndEdgeIdx = mainEndEdge(parentDirection);
+                // Phase 17: fold prevMarginEnd and myMarginMainStart when at default (0).
+                const fPrevMarginEnd = foldMargin(prevSibling, mainEndEdgeIdx);
+                const fMyMarginMainStart = foldMargin(node, mainStartEdgeIdx);
+                const mainGapInput = gapInput(parent, parentDirection === 'column' ? 'row' : 'column');
+                grammar.set(mainPosField, {
+                    deps: [
+                        prevMainPos,
+                        prevMainSize,
+                        ...foldedDeps([fPrevMarginEnd, fMyMarginMainStart]),
+                        mainGapInput,
+                    ],
+                    compute: (read) => read(prevMainPos) +
+                        read(prevMainSize) +
+                        readFolded(fPrevMarginEnd, read) +
+                        readFolded(fMyMarginMainStart, read) +
+                        read(mainGapInput),
+                });
+            }
             else {
-                // Non-qualifying regime (wrap): keep today's prior-siblings-sum
-                // rule — size / spacing mutation on any prior sibling propagates here.
+                // Reverse direction: keep the cumulative-sum rule. The recurrence
+                // cannot chain through the predecessor's mainPosField here because
+                // applyReverseMainPos (applied per-sibling below) overwrites that
+                // field with a reflected value — the predecessor's field no longer
+                // carries the forward cursor the recurrence depends on.
                 const priorMainSizes = priorSiblings.map((s) => field(s, mainSizeName));
                 const priorMargins = priorSiblings.map((s) => ({
                     start: marginInput(s, mainStartEdge(parentDirection)),
                     end: marginInput(s, mainEndEdge(parentDirection)),
                 }));
                 const mainGapInput = gapInput(parent, parentDirection === 'column' ? 'row' : 'column');
+                // Reverse cumulative-sum: cannot fold margins — the expression
+                // accumulates all sibling margins and this node's own marginMainStart.
+                const myMMS = getMarginMainStart();
                 grammar.set(mainPosField, {
                     deps: [
                         mainGapInput,
                         padMainStartF,
-                        myMarginMainStartF,
+                        myMMS,
                         ...priorMainSizes,
                         ...priorMargins.flatMap((m) => [m.start, m.end]),
                     ],
                     compute: (read) => {
-                        let sum = read(padMainStartF) + read(myMarginMainStartF) + indexInParent * read(mainGapInput);
+                        let sum = read(padMainStartF) + read(myMMS) + indexInParent * read(mainGapInput);
                         for (const m of priorMargins)
                             sum += read(m.start) + read(m.end);
                         for (const m of priorMainSizes)
@@ -885,13 +1009,14 @@ function makeEmitter(ctx) {
         if (parent === null || align === 'flex-end') {
             if (parent !== null && align === 'flex-end') {
                 const parentCrossField = field(parent, parentDirection === 'column' ? 'width' : 'height');
+                const mce = getMarginCrossEnd();
                 grammar.set(crossPosField, {
                     deps: [
                         parentCrossField,
                         crossSizeField,
                         padCrossStartF,
                         padCrossEndF,
-                        myMarginCrossEndF,
+                        mce,
                     ],
                     // Anchor against the line's inner cross, which the
                     // imperative `crossAlignItemsInLine` clamps to >= 0 — a
@@ -900,10 +1025,7 @@ function makeEmitter(ctx) {
                     compute: (read) => {
                         const padStart = read(padCrossStartF);
                         const innerCross = Math.max(0, read(parentCrossField) - padStart - read(padCrossEndF));
-                        return (padStart +
-                            innerCross -
-                            read(crossSizeField) -
-                            read(myMarginCrossEndF));
+                        return padStart + innerCross - read(crossSizeField) - read(mce);
                     },
                 });
             }
@@ -917,20 +1039,22 @@ function makeEmitter(ctx) {
         }
         else if (align === 'center') {
             const parentCrossField = field(parent, parentDirection === 'column' ? 'width' : 'height');
+            const mcs2 = getMarginCrossStart();
+            const mce2 = getMarginCrossEnd();
             grammar.set(crossPosField, {
                 deps: [
                     parentCrossField,
                     crossSizeField,
                     padCrossStartF,
                     padCrossEndF,
-                    myMarginCrossStartF,
-                    myMarginCrossEndF,
+                    mcs2,
+                    mce2,
                 ],
                 compute: (read) => {
                     const padStart = read(padCrossStartF);
                     const innerCross = Math.max(0, read(parentCrossField) - padStart - read(padCrossEndF));
-                    const marginStart = read(myMarginCrossStartF);
-                    const innerLine = innerCross - marginStart - read(myMarginCrossEndF);
+                    const marginStart = read(mcs2);
+                    const innerLine = innerCross - marginStart - read(mce2);
                     const myCross = read(crossSizeField);
                     return padStart + marginStart + Math.max(0, (innerLine - myCross) / 2);
                 },
@@ -940,11 +1064,13 @@ function makeEmitter(ctx) {
             // flex-start, stretch (with explicit cross size — no resize),
             // and any other value (the imperative falls through to
             // flex-start) all share this offset: the parent's cross-start
-            // padding plus this child's cross-start margin, both declared
-            // input deps.
+            // padding plus this child's cross-start margin.
+            // Phase 17: fold myMarginCrossStart when at default (0) — no Field
+            // created, constant 0 inlined.
+            const fMyMarginCrossStart = foldMargin(node, crossStartEdgeIdx);
             grammar.set(crossPosField, {
-                deps: [padCrossStartF, myMarginCrossStartF],
-                compute: (read) => read(padCrossStartF) + read(myMarginCrossStartF),
+                deps: [padCrossStartF, ...foldedDeps([fMyMarginCrossStart])],
+                compute: (read) => read(padCrossStartF) + readFolded(fMyMarginCrossStart, read),
             });
         }
         allFields.push({ node, width, height, left, top });
@@ -1049,8 +1175,11 @@ function mergeStyleInputs(a, b) {
  * which gains a main-end margin input when it acquires a follower —
  * has its `StyleInputs` deep-merged rather than overwritten.
  */
-function mergeStyleInputsMap(base, extra) {
-    const merged = new Map(base);
+function mergeStyleInputsMap(base, extra, mutateBase) {
+    // When mutateBase is true the caller owns `base` exclusively (it is
+    // the previous grammar output, swapped out by the caller right after
+    // this returns) — mutate it directly and skip the ~1,100-entry clone.
+    const merged = mutateBase ? base : new Map(base);
     for (const [node, entry] of extra) {
         const existing = merged.get(node);
         merged.set(node, existing === undefined ? entry : mergeStyleInputs(existing, entry));
@@ -1151,7 +1280,7 @@ export function buildAppendFragment(prev, root, parent, child, available = {}) {
             grammar: prev.grammar,
             rootFields: prev.rootFields,
             allFields: [...prev.allFields, ...ctx.allFields],
-            styleInputs: mergeStyleInputsMap(prev.styleInputs, ctx.styleInputs),
+            styleInputs: mergeStyleInputsMap(prev.styleInputs, ctx.styleInputs, true),
             availableInputs: prev.availableInputs,
             mainDistributionByParent: prev.mainDistributionByParent,
         };
@@ -1337,13 +1466,20 @@ export function buildRemoveFragment(prev, root, parent, child, available = {}) {
                     removed.push(f);
             }
         }
+        // Mutate prev.styleInputs and prev.mainDistributionByParent in place:
+        // `prev` is the old grammar output, single-use — the caller swaps
+        // built.output to the new fragment immediately after this returns.
+        for (const n of removedNodes) {
+            prev.styleInputs.delete(n);
+            prev.mainDistributionByParent.delete(n);
+        }
         const next = {
             grammar: prev.grammar,
             rootFields: prev.rootFields,
             allFields: prev.allFields.filter((e) => !removedNodes.has(e.node)),
-            styleInputs: new Map([...prev.styleInputs].filter(([n]) => !removedNodes.has(n))),
+            styleInputs: prev.styleInputs,
             availableInputs: prev.availableInputs,
-            mainDistributionByParent: new Map([...prev.mainDistributionByParent].filter(([n]) => !removedNodes.has(n))),
+            mainDistributionByParent: prev.mainDistributionByParent,
         };
         return { removed, rebinds: [], next };
     }