@nowline/layout 0.8.5 → 0.9.0

package/src/resolve-today.ts

@@ -20,6 +20,8 @@
 //    --timezone is ignored. --timezone only governs the clock-based default
 //    (when --now is omitted).
 
+import { ISO_DATE_RE, isRealIsoDate, parseIsoDate } from '@nowline/core/internal';
+
 // ---- Types and errors -------------------------------------------------------
 
 /**
@@ -145,17 +147,25 @@ export function civilDateInZone(instant: Date, zone: NormalizedZone): Date {
 
 // ---- Now-value parsing ------------------------------------------------------
 
-// Bare YYYY-MM-DD (floating date, zone-independent)
-const BARE_DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
-
 // ISO 8601 instant with explicit Z or ±HH / ±HH:MM / ±HHMM offset.
 // Captures: [1] datetime part, [2] sign or Z, [3] hours, [4] minutes (optional)
 const ISO_WITH_OFFSET_RE =
     /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?)(Z|([+-])(\d{2})(?::?(\d{2}))?)$/;
 
 // ISO 8601 with time but no offset (floating local date-time).
-// Captures: [1] year, [2] month, [3] day
-const ISO_FLOATING_RE = /^(\d{4})-(\d{2})-(\d{2})T\d{2}:\d{2}:\d{2}(?:\.\d+)?$/;
+const ISO_FLOATING_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?$/;
+
+/**
+ * True when `raw` has one of the `now` string shapes but its leading
+ * `YYYY-MM-DD` is not a real calendar day (`2026-02-30`). {@link resolveToday}
+ * returns undefined for such a value, as for any unrecognised string; this
+ * lets an option parser say why.
+ */
+export function hasImpossibleNowDate(raw: string): boolean {
+    const isNowShape =
+        ISO_DATE_RE.test(raw) || ISO_WITH_OFFSET_RE.test(raw) || ISO_FLOATING_RE.test(raw);
+    return isNowShape && !isRealIsoDate(raw.slice(0, 10));
+}
 
 // ---- Public API -------------------------------------------------------------
 
@@ -193,11 +203,14 @@ export interface ResolveTodayOptions {
  * Precedence (from highest to lowest):
  *  1. `now === '-'` / `null`       → `undefined` (suppress)
  *  2. `now` is a `Date` object     → returned as-is (caller must supply UTC midnight)
- *  3. `now` bare `YYYY-MM-DD`      → floating; `Date.UTC(y, m, d)` regardless of zone
+ *  3. `now` bare `YYYY-MM-DD`      → floating; UTC midnight of that day regardless of zone
  *  4. `now` ISO 8601 + Z/offset    → embedded offset wins; zone ignored
  *  5. `now` ISO 8601 without offset→ floating; written date part; zone ignored
  *  6. `now` omitted                → civil date of `clock()` in effective `zone`
  *
+ * A string whose `YYYY-MM-DD` is not a real calendar day (`2026-02-30`) is
+ * rejected like an unrecognised one, never rolled over to the next month.
+ *
  * The `zone` is ONLY consulted for case 6 (clock-based default). Authored
  * dates — item bars, milestones, anchors, the axis ticks — are floating and
  * are never affected by this function.
@@ -214,17 +227,14 @@ export function resolveToday(opts: ResolveTodayOptions = {}): Date | undefined {
     if (now instanceof Date) return now;
 
     if (now !== undefined) {
+        // Every string form leads with a YYYY-MM-DD. `Date.UTC` and `new Date`
+        // would both roll an impossible one over (`2026-02-30` to March 2), so
+        // reject it here and let the option layer report it.
+        if (hasImpossibleNowDate(now)) return undefined;
+
         // 3. Bare YYYY-MM-DD — floating; zone ignored
-        const bareMatch = BARE_DATE_RE.exec(now);
-        if (bareMatch) {
-            return new Date(
-                Date.UTC(
-                    parseInt(bareMatch[1], 10),
-                    parseInt(bareMatch[2], 10) - 1,
-                    parseInt(bareMatch[3], 10),
-                ),
-            );
-        }
+        const bare = parseIsoDate(now);
+        if (bare) return bare;
 
         // 4. ISO 8601 instant with explicit Z or offset — embedded offset WINS
         const withOffset = ISO_WITH_OFFSET_RE.exec(now);
@@ -245,15 +255,8 @@ export function resolveToday(opts: ResolveTodayOptions = {}): Date | undefined {
         }
 
         // 5. ISO 8601 without offset — floating; use written date part; zone ignored
-        const floating = ISO_FLOATING_RE.exec(now);
-        if (floating) {
-            return new Date(
-                Date.UTC(
-                    parseInt(floating[1], 10),
-                    parseInt(floating[2], 10) - 1,
-                    parseInt(floating[3], 10),
-                ),
-            );
+        if (ISO_FLOATING_RE.test(now)) {
+            return parseIsoDate(now.slice(0, 10)) ?? undefined;
         }
 
         // Unrecognised string — caller should have validated before calling.

package/src/row-packer.ts

@@ -1,8 +1,10 @@
-// RowPacker — the topmost-fit row-pack engine shared by `SwimlaneNode`
-// and `GroupNode`. Tracks rows of variable height (each row's height is
-// the max of its placed children's heights, with a per-packer minimum)
-// and bumps a child to a new row when it would collide with a sibling's
-// `rightEdge`, caption `spillX`, or a slack-arrow corridor.
+// RowPacker — the row-pack engine shared by `SwimlaneNode` and
+// `GroupNode`. A child never lands above the one before it
+// (specs/true-width-layout.md §3.2), so it either joins the last row or
+// opens a new one below it: it drops a row when it would collide with the
+// last row's `rightEdge`, caption `spillX`, or a slack-arrow corridor.
+// Each row's height is the max of its placed children's heights, with a
+// per-packer minimum.
 //
 // Two-phase API per child:
 //   1) `placeItem(...)` / `placeBlock(...)` decides which row the child
@@ -12,12 +14,8 @@
 //      back into the packer so the row's `rightEdge` / `spillX` advance
 //      and the row's height grows to accommodate the new child.
 //
-// When a row's height grows after later rows already exist, the packer
-// shifts every subsequent row (and every positioned child placed in it)
-// downward by the delta. Items keep their row-anchored top edge; the
-// row simply gets taller. This keeps the contract "all children in a
-// row share that row's top y" intact while letting individual children
-// grow vertically (e.g. wrapped label-chiclet stacks in m3).
+// A child only ever commits to the last row, so a row that grows has no
+// rows below it to move.
 
 import type { PositionedItem, PositionedTrackChild, SlackCorridor } from './types.js';
 
@@ -31,10 +29,11 @@ export interface PackedRow {
     /** Reserved x for caption spill. Items whose `desiredStart < spillX`
      *  bump to a new row even if `rightEdge` would let them in. */
     spillX: number;
-    /** Children placed in this row. Used when the row's height grows
-     *  after later rows exist — every child in every later row shifts
-     *  down by the delta. */
-    placedChildren: PositionedTrackChild[];
+    /** How far below `y` an item joining this row sits: 0 for a row of items,
+     *  and for a row a parallel or group opened, the distance from its top to
+     *  its first track, so the item beside it aligns with that track rather
+     *  than with the block's header band. */
+    contentOffsetY: number;
 }
 
 export interface RowPackerOptions {
@@ -64,6 +63,10 @@ export interface ItemPlacementInput {
      *  initial height when this is the first item in a fresh row, or
      *  to grow the row when a taller item lands in an existing row. */
     predictedHeight: number;
+    /** Ids of the items still to come in this track. A slack corridor
+     *  whose arrow starts at one of them never bumps this item: rows
+     *  never move up, so that item would follow it down. */
+    pendingIds?: ReadonlySet<string>;
 }
 
 /** Result of a `placeItem` query. */
@@ -76,10 +79,9 @@ export interface ItemPlacement {
 export interface ItemCommitInput {
     rowIndex: number;
     placed: PositionedItem;
-    /** Logical right edge of the placed item. Includes the trailing
-     *  `ITEM_INSET_PX` so the next chained item butts edge-to-edge in
-     *  logical space (with a 2 × ITEM_INSET_PX visible gutter between
-     *  bars). */
+    /** Logical right edge of the placed item: its span in time, so the
+     *  next chained item butts edge-to-edge in logical space (each bar
+     *  keeps its seams inside its own dates). */
     logicalEnd: number;
     /** Reserved spill x for captions that overflow the bar's right
      *  edge. `null` resets the row's spill reservation to `laneLeftX`. */
@@ -111,40 +113,58 @@ export interface BlockCommitInput {
     blockHeight: number;
     /** Logical right edge of the block. */
     blockEnd: number;
+    /** Distance from the block's top to its first track (header band plus
+     *  body pad); 0 when it has no header or children. An item that joins
+     *  the block's row lands this far down. */
+    contentOffsetY?: number;
+    /** Reserved spill x for what the block paints past its right edge
+     *  (a header title, a caption its children spill). Omitted or
+     *  `null` resets the row's spill reservation to `laneLeftX`. */
+    spillReservation?: number | null;
+    /** Rightmost x anything inside the block paints, when it can pass
+     *  `blockEnd` (see `trackChildPaintedRightX`): a container's box spans
+     *  only its dates, so a caption its children spill is not in it. It widens
+     *  `usedRightX()` (the lane's extent, and so the canvas); the
+     *  caller reserves it on the row through `spillReservation`. */
+    paintedRight?: number;
 }
 
 export class RowPacker {
     public readonly rows: PackedRow[];
     private readonly opts: RowPackerOptions;
+    /** Rightmost `BlockCommitInput.paintedRight` committed so far. */
+    private paintedRightX: number;
 
     constructor(opts: RowPackerOptions) {
         this.opts = opts;
+        this.paintedRightX = opts.laneLeftX;
         this.rows = [
             {
                 y: opts.originY,
                 height: opts.minRowHeight,
                 rightEdge: opts.laneLeftX,
                 spillX: opts.laneLeftX,
-                placedChildren: [],
+                contentOffsetY: 0,
             },
         ];
     }
 
     /**
-     * Find the topmost row where the item's natural extent fits without
-     * colliding with sibling content or a slack corridor; appending a
-     * fresh row at the bottom when none of the existing rows fit.
+     * Join the last row (the last committed child's) when the item's natural
+     * extent fits there without colliding with sibling content or a slack
+     * corridor; otherwise append a fresh row below it.
      */
     placeItem(input: ItemPlacementInput): ItemPlacement {
-        for (let i = 0; i < this.rows.length; i += 1) {
-            const r = this.rows[i];
-            if (input.desiredStart < r.rightEdge) continue;
-            if (input.desiredStart < r.spillX) continue;
-            if (this.rowIntersectsCorridor(r, input)) continue;
-            return { rowIndex: i, y: r.y };
-        }
-        const fresh = this.appendRow(Math.max(this.opts.minRowHeight, input.predictedHeight));
-        return { rowIndex: this.rows.length - 1, y: fresh.y };
+        const last = this.rows[this.rows.length - 1];
+        const fits =
+            input.desiredStart >= last.rightEdge &&
+            input.desiredStart >= last.spillX &&
+            !this.rowIntersectsCorridor(last, input) &&
+            !this.rowCrossesOwnCorridor(last, input);
+        const row = fits
+            ? last
+            : this.appendRow(Math.max(this.opts.minRowHeight, input.predictedHeight));
+        return { rowIndex: this.rows.length - 1, y: row.y + row.contentOffsetY };
     }
 
     /**
@@ -164,16 +184,16 @@ export class RowPacker {
 
     /**
      * Record a placed item back into its row. Grows the row's height to
-     * fit the item, advances `rightEdge`, sets the caption spill, and
-     * shifts later rows down if this row got taller.
+     * fit the item, advances `rightEdge` and sets the caption spill.
      */
     commitItem(input: ItemCommitInput): void {
         const row = this.rows[input.rowIndex];
-        const target = Math.max(input.placed.box.height, input.rowHeight ?? 0);
-        this.growRowHeight(input.rowIndex, target);
+        row.height = Math.max(
+            row.height,
+            row.contentOffsetY + Math.max(input.placed.box.height, input.rowHeight ?? 0),
+        );
         row.rightEdge = input.logicalEnd;
         row.spillX = input.spillReservation ?? this.opts.laneLeftX;
-        row.placedChildren.push(input.placed);
     }
 
     /**
@@ -182,10 +202,13 @@ export class RowPacker {
      */
     commitBlock(input: BlockCommitInput): void {
         const row = this.rows[input.rowIndex];
-        this.growRowHeight(input.rowIndex, input.blockHeight);
+        row.height = Math.max(row.height, input.blockHeight);
+        row.contentOffsetY = input.contentOffsetY ?? 0;
         row.rightEdge = input.blockEnd;
-        row.spillX = this.opts.laneLeftX;
-        row.placedChildren.push(input.placed);
+        row.spillX = input.spillReservation ?? this.opts.laneLeftX;
+        if (input.paintedRight !== undefined && input.paintedRight > this.paintedRightX) {
+            this.paintedRightX = input.paintedRight;
+        }
     }
 
     /** Total vertical extent reached (last row's bottom - originY). */
@@ -195,10 +218,11 @@ export class RowPacker {
     }
 
     /** Rightmost extent reached — bar logical end OR caption spill,
-     *  whichever is wider, across every row. Empty rows contribute
-     *  `laneLeftX`. */
+     *  whichever is wider, across every row, and anything a committed
+     *  block paints past its own box (`BlockCommitInput.paintedRight`).
+     *  Empty rows contribute `laneLeftX`. */
     usedRightX(): number {
-        let x = this.opts.laneLeftX;
+        let x = this.paintedRightX;
         for (const r of this.rows) {
             if (r.rightEdge > x) x = r.rightEdge;
             if (r.spillX > x) x = r.spillX;
@@ -213,7 +237,23 @@ export class RowPacker {
                 c.y < r.y + r.height &&
                 p.desiredStart < c.xEnd &&
                 p.desiredEnd > c.xStart &&
-                c.slackPredId !== p.childId,
+                c.slackPredId !== p.childId &&
+                !p.pendingIds?.has(c.slackPredId),
+        );
+    }
+
+    /**
+     * An overrun slack arrow runs left, from its source back to a milestone
+     * dated before the source ends. Rows never move up, so the source cannot
+     * push the work before it out of that path; it drops to a row where the
+     * path is clear instead.
+     */
+    private rowCrossesOwnCorridor(r: PackedRow, p: ItemPlacementInput): boolean {
+        return this.opts.slackCorridors.some(
+            (c) =>
+                c.slackPredId === p.childId &&
+                c.xStart < p.desiredStart &&
+                r.rightEdge > Math.max(c.xStart, this.opts.laneLeftX),
         );
     }
 
@@ -224,48 +264,9 @@ export class RowPacker {
             height,
             rightEdge: this.opts.laneLeftX,
             spillX: this.opts.laneLeftX,
-            placedChildren: [],
+            contentOffsetY: 0,
         };
         this.rows.push(r);
         return r;
     }
-
-    private growRowHeight(rowIndex: number, newHeight: number): void {
-        const row = this.rows[rowIndex];
-        const delta = newHeight - row.height;
-        if (delta <= 0) return;
-        row.height = newHeight;
-        for (let i = rowIndex + 1; i < this.rows.length; i += 1) {
-            const r = this.rows[i];
-            r.y += delta;
-            for (const child of r.placedChildren) {
-                shiftPositionedY(child, delta);
-            }
-        }
-    }
-}
-
-/**
- * Walk a positioned subtree and shift every absolute y by `dy`. Used
- * when an earlier row in the packer grows, retroactively pushing every
- * later row (and its placed subtrees) down to keep them clear.
- *
- * Items: shift the bar box plus label chips and any overflow box.
- * Groups / parallels: shift the container box and recurse into
- * children. The caller's `box.y` already moved with the parent.
- */
-function shiftPositionedY(p: PositionedTrackChild, dy: number): void {
-    p.box.y += dy;
-    if (p.kind === 'item') {
-        for (const chip of p.labelChips) {
-            chip.box.y += dy;
-        }
-        if (p.overflowBox) {
-            p.overflowBox.y += dy;
-        }
-        return;
-    }
-    for (const child of p.children) {
-        shiftPositionedY(child, dy);
-    }
 }