@nowline/layout 0.8.6 → 0.10.0

package/src/nodes/include-node.ts

@@ -5,24 +5,20 @@
 // reserved 18 px above the first region; subsequent regions are
 // separated by GAP_BETWEEN_REGIONS px.
 
-import type {
-    EntityProperty,
-    GroupBlock,
-    IsolatedRegion,
-    ItemDeclaration,
-    ParallelBlock,
-} from '@nowline/core';
-import { resolveSizes } from '../calendar.js';
+import type { IsolatedRegion } from '@nowline/core';
+import { translateSwimlaneY } from '../chart-translation.js';
 import { includeChromeGeometry } from '../include-chrome-geometry.js';
-import type { LayoutContext, TrackCursor } from '../layout-context.js';
+import { createLayoutContext, type LayoutContext, type LayoutHelpers } from '../layout-context.js';
 import { resolveStyle } from '../style-resolution.js';
-import type {
-    BoundingBox,
-    PositionedIncludeRegion,
-    PositionedItem,
-    PositionedSwimlane,
-    PositionedTrackChild,
-} from '../types.js';
+import type { BoundingBox, PositionedIncludeRegion, PositionedSwimlane } from '../types.js';
+import { seedWaveEdges } from '../wave-layout.js';
+import { maxLeafItemRightX } from './content-extent.js';
+import { indexFootnotes } from './footnote-node.js';
+import {
+    placeRegionMarkers,
+    regionMarkerLabelsRightX,
+    seedRegionAnchorEdges,
+} from './region-markers.js';
 import { SwimlaneNode } from './swimlane-node.js';
 
 const TAB_RESERVE = 18;
@@ -31,103 +27,82 @@ const REGION_INSET_BOTTOM = 14;
 const GAP_BETWEEN_REGIONS = 16;
 
 // Visual breathing room added past the rightmost element when sizing
-// the include's bounding box. Keeps the dashed bracket from butting up
-// against an item's right edge while still trimming the wide
-// chart-width whitespace left over from full-width sizing.
-const INCLUDE_CONTENT_RIGHT_PAD_PX = 32;
-
-export interface IncludeNodeDeps {
-    sequenceItem: (
-        child: ItemDeclaration,
-        cursor: TrackCursor,
-        ctx: LayoutContext,
-        ownerOverride?: string,
-    ) => PositionedItem;
-    sequenceOne: (
-        child: ItemDeclaration | GroupBlock | ParallelBlock,
-        cursor: TrackCursor,
-        ctx: LayoutContext,
-    ) => PositionedTrackChild;
-    resolveChildStart: (
-        props: EntityProperty[],
-        seqDefault: number,
-        laneLeftX: number,
-        ctx: LayoutContext,
-    ) => number;
-    newCursor: (x: number, y: number) => TrackCursor;
-    estimateTextWidth: (text: string, fontSize: number) => number;
-    predictItemChipExtraHeight: (item: ItemDeclaration, ctx: LayoutContext) => number;
-}
+// the include's bounding box. The rightmost element is the diagram's, not
+// the region's own: every region reaches the same edge, past the furthest
+// bar, spilled caption, marker or now-line anywhere in the chart. The
+// renderer insets the dashed rect by 8 px, so its edge sits 16 px past it.
+const INCLUDE_CONTENT_RIGHT_PAD_PX = 24;
 
 export function buildIncludeRegions(
     regions: IsolatedRegion[],
     ctx: LayoutContext,
     startY: number,
-    deps: IncludeNodeDeps,
-): { regions: PositionedIncludeRegion[]; endY: number } {
+    helpers: LayoutHelpers,
+    chartRightX: number,
+): { regions: PositionedIncludeRegion[]; contexts: LayoutContext[]; endY: number } {
     let y = startY + TAB_RESERVE;
     const out: PositionedIncludeRegion[] = [];
+    const contexts: LayoutContext[] = [];
     let isFirst = true;
+    // Region footnotes number on after the host's, in include order.
+    let footnotesBefore = ctx.footnoteIndex.size;
     for (const region of regions) {
         if (!isFirst) y += GAP_BETWEEN_REGIONS;
         isFirst = false;
         const label = region.content.roadmap?.title ?? region.sourcePath;
         const innerStartY = y + REGION_INSET_TOP;
-        const childCtx: LayoutContext = {
-            cal: ctx.cal,
-            styleCtx: {
+        const childCtx = createLayoutContext(
+            region,
+            {
                 theme: ctx.styleCtx.theme,
-                styles: region.config.styles,
-                defaults: region.config.defaults,
-                labels: region.content.labels,
+                cal: ctx.cal,
+                schedule: ctx.schedule,
+                timeline: ctx.timeline,
+                scale: ctx.scale,
+                calendar: ctx.calendar,
+                axisColumns: ctx.axisColumns,
+                bandScale: ctx.bandScale,
+                waves: ctx.waves,
             },
-            // Each include region declares its own sizes; resolve them under
-            // the parent's calendar so child sized items render at the same
-            // pixels-per-day scale as the host roadmap.
-            sizes: resolveSizes(region.content.sizes, ctx.cal),
-            labels: region.content.labels,
-            teams: region.content.teams,
-            persons: region.content.persons,
-            symbols: region.config.symbols,
-            footnoteIndex: new Map(),
-            footnoteHosts: new Map(),
-            timeline: ctx.timeline,
-            scale: ctx.scale,
-            calendar: ctx.calendar,
-            bandScale: ctx.bandScale,
-            entityLeftEdges: new Map(),
-            entityRightEdges: new Map(),
-            entityMidpoints: new Map(),
-            entityVisualLeftX: new Map(),
-            entityVisualRightX: new Map(),
-            itemArrowSource: new Map(),
-            itemFlowKey: new Map(),
-            currentFlowKey: '',
-            itemSlackAttachY: new Map(),
-            slackCorridors: [],
-            markerRowPlacements: new Map(),
-            chartTopY: innerStartY,
-            chartBottomY: innerStartY,
-            swimlaneBottomY: innerStartY,
-            chartRightX: ctx.chartRightX,
-            nextParallelId: 0,
-            nextGroupId: 0,
-        };
+            {
+                chartTopY: innerStartY,
+                chartBottomY: innerStartY,
+                swimlaneBottomY: innerStartY,
+            },
+            { footnotes: indexFootnotes(region.content.footnotes, footnotesBefore) },
+        );
+        footnotesBefore += region.content.footnotes.size;
+        // Region ids stay invisible to the host, but the wave edges are
+        // shared: seed them into the region's otherwise empty edge maps.
+        // Without waves, the region's own dated anchors resolve inside it
+        // instead, as engine C's `scheduleRegion` resolves them, so a lane
+        // `after:kickoff` naming the region's anchor starts on its date
+        // (specs/scheduler-unification.md §5 F5).
+        if (ctx.waves) {
+            seedWaveEdges(ctx.waves, childCtx.entityLeftEdges, childCtx.entityRightEdges);
+        } else {
+            seedRegionAnchorEdges(region.content.anchors, childCtx);
+        }
         const nestedSwimlanes: PositionedSwimlane[] = [];
         let cursorY = innerStartY;
         let bandIndex = 0;
-        let nestedContentRightX = childCtx.timeline.originX;
         for (const lane of region.content.swimlanes.values()) {
             childCtx.nextParallelId = 0;
             childCtx.nextGroupId = 0;
-            const { positioned, usedHeight, usedRightX } = new SwimlaneNode(
-                { lane, bandIndex },
-                deps,
-            ).place({ x: childCtx.timeline.originX, y: cursorY }, childCtx);
+            const { positioned, usedHeight } = new SwimlaneNode({ lane, bandIndex }, helpers).place(
+                { x: childCtx.timeline.originX, y: cursorY },
+                childCtx,
+            );
             nestedSwimlanes.push(positioned);
             cursorY += usedHeight;
             bandIndex++;
-            if (usedRightX > nestedContentRightX) nestedContentRightX = usedRightX;
+        }
+        // The region's own anchors and milestones take a marker row under
+        // its label tab, and the lanes move down below it.
+        const markers = placeRegionMarkers(region, childCtx, y, innerStartY, cursorY, chartRightX);
+        if (markers.laneShift !== 0) {
+            for (const lane of nestedSwimlanes) translateSwimlaneY(lane, markers.laneShift);
+            cursorY += markers.laneShift;
         }
         const innerEndY = cursorY;
         // Floor the region height to one row's bandwidth so an empty or
@@ -137,36 +112,75 @@ export function buildIncludeRegions(
             ctx.bandScale.bandwidth(),
             innerEndY - y + REGION_INSET_BOTTOM,
         );
-        // Shrink-wrap the include's bounding box to fit chrome + content
-        // (with a small right pad) instead of stretching to the full
-        // chart width. An include that reaches past the timeline still
-        // gets clamped to the chart's natural right edge so it never
-        // extends into the attribution / right-margin area.
-        const boxX = 0;
-        const { chromeRightX } = includeChromeGeometry(boxX, label, region.sourcePath);
-        const naturalRightX =
-            Math.max(chromeRightX, nestedContentRightX) + INCLUDE_CONTENT_RIGHT_PAD_PX;
-        const boxWidth = Math.min(ctx.chartRightX - boxX, naturalRightX - boxX);
+        // The width waits for the final canvas: finalize (f4) fits every
+        // kept region with `fitIncludeRegionWidth` once the canvas stops
+        // growing, so placement never reads the canvas.
         const box: BoundingBox = {
-            x: boxX,
+            x: 0,
             y,
-            width: boxWidth,
+            width: 0,
             height: regionHeight,
         };
-        // Mirror the shrunk width onto each nested swimlane band so the
-        // tinted background fits inside the dashed bracket instead of
-        // bleeding past it on the right.
-        for (const lane of nestedSwimlanes) {
-            lane.box.width = boxWidth;
-        }
-        out.push({
+        const positioned: PositionedIncludeRegion = {
             sourcePath: region.sourcePath,
             label,
             box,
             nestedSwimlanes,
             style: resolveStyle('swimlane', [], ctx.styleCtx),
-        });
+        };
+        if (markers.anchors.length > 0) positioned.anchors = markers.anchors;
+        if (markers.milestones.length > 0) positioned.milestones = markers.milestones;
+        out.push(positioned);
+        contexts.push(childCtx);
         y += regionHeight;
     }
-    return { regions: out, endY: y };
+    return { regions: out, contexts, endY: y };
+}
+
+/**
+ * Size an include's bounding box to the diagram's content: it reaches past
+ * `contentRightX`, the furthest bar, spilled caption, marker or now-line
+ * anywhere in the chart (and past its own chrome), by a small right pad,
+ * so every region in a chart ends at the same edge (specs/rendering.md,
+ * Included Roadmaps). It is clamped to `chartRightX`;
+ * finalize grows the canvas to hold the pad first (f3). Finalize runs it
+ * once per kept region (f4), after the canvas width is final: the spill
+ * growth, the timeline extension and the marker labels can all still grow
+ * the canvas after the region is placed.
+ */
+export function fitIncludeRegionWidth(
+    region: PositionedIncludeRegion,
+    chartRightX: number,
+    contentRightX: number,
+): void {
+    const boxWidth = includeRegionWidth(region, chartRightX, contentRightX);
+    region.box.width = boxWidth;
+    // Mirror the shrunk width onto each nested swimlane band so the
+    // tinted background fits inside the dashed bracket instead of
+    // bleeding past it on the right.
+    for (const lane of region.nestedSwimlanes) {
+        lane.box.width = boxWidth;
+    }
+}
+
+/**
+ * The width `fitIncludeRegionWidth` gives `region` on a canvas ending at
+ * `chartRightX`, with the diagram's content ending at `contentRightX`.
+ */
+export function includeRegionWidth(
+    region: PositionedIncludeRegion,
+    chartRightX: number,
+    contentRightX: number,
+): number {
+    const boxX = region.box.x;
+    const { chromeRightX } = includeChromeGeometry(boxX, region.label, region.sourcePath);
+    // Bars-only extent (never a spilled caption — see
+    // `maxLeafItemRightX`), so a long trailing item caption inside
+    // the include can overhang the dashed bracket instead of
+    // dragging it wider.
+    const barsRightX = maxLeafItemRightX(region.nestedSwimlanes);
+    const naturalRightX =
+        Math.max(chromeRightX, barsRightX, regionMarkerLabelsRightX(region), contentRightX) +
+        INCLUDE_CONTENT_RIGHT_PAD_PX;
+    return Math.min(chartRightX - boxX, naturalRightX - boxX);
 }