@nowline/layout 0.8.6 → 0.9.0

package/src/nodes/parallel-node.ts

@@ -1,31 +1,29 @@
 // ParallelNode — Renderable for a `parallel { ... }` block. Stacks
-// children top-to-bottom (each child owns a fresh sub-track) and reports
-// the union bounding box. Each child is sequenced via the injected
-// `deps.sequenceOne` callback, which dispatches to the appropriate
-// per-entity Renderable (or, transitionally, the legacy sequencer
-// helpers in `layout.ts`).
+// children top-to-bottom inside its body (each child owns a fresh
+// sub-track) under a header band, the way a group is drawn
+// (specs/true-width-layout.md §3.3; `container-header-geometry.ts`). Each
+// child is sequenced via the injected `helpers.sequenceOne` callback
+// (`sequence-one.ts`), which dispatches to `sequenceItem`, `GroupNode` or a
+// nested `ParallelNode`.
 
 import type { GroupBlock, ItemDeclaration, ParallelBlock } from '@nowline/core';
+import { containerChrome } from '../container-header-geometry.js';
 import { propValues } from '../dsl-utils.js';
 import { computeContainerInlineDatePins, pickInlineDate } from '../inline-date-pin-geometry.js';
-import type { LayoutContext, TrackCursor } from '../layout-context.js';
+import {
+    type LayoutContext,
+    type LayoutHelpers,
+    newCursor,
+    type TrackCursor,
+} from '../layout-context.js';
 import { resolveStyle } from '../style-resolution.js';
-import { TRACK_BLOCK_TAIL_GUTTER_PX } from '../themes/shared.js';
 import type { BoundingBox, PositionedParallel, PositionedTrackChild } from '../types.js';
-
-export interface ParallelNodeDeps {
-    sequenceOne: (
-        child: ItemDeclaration | GroupBlock | ParallelBlock,
-        cursor: TrackCursor,
-        ctx: LayoutContext,
-    ) => PositionedTrackChild;
-    newCursor: (x: number, y: number) => TrackCursor;
-}
+import { waveFloorX } from '../wave-layout.js';
 
 export class ParallelNode {
     constructor(
         public readonly node: ParallelBlock,
-        private readonly deps: ParallelNodeDeps,
+        private readonly helpers: LayoutHelpers,
     ) {}
 
     get id(): string {
@@ -34,18 +32,33 @@ export class ParallelNode {
 
     /**
      * Sequence children into stacked sub-tracks, advance the parent
-     * `cursor` past the parallel's right edge plus
-     * `TRACK_BLOCK_TAIL_GUTTER_PX` of breathing room, and return a
-     * `PositionedParallel`.
+     * `cursor` to the parallel's end in time (the latest track end), and
+     * return a `PositionedParallel`.
      */
     place(cursor: TrackCursor, ctx: LayoutContext): PositionedParallel {
         const { node } = this;
-        const { deps } = this;
+        const { helpers } = this;
         const style = resolveStyle('parallel', node.properties, ctx.styleCtx);
-        const startX = cursor.x;
-        const startY = cursor.y;
+        // The block's own wave and its lead wave floor the shared start
+        // (specs/waves.md §5.1); each track is floored again by its own
+        // wave where it is placed. A no-op without waves.
+        const startX = waveFloorX(node, cursor.x, ctx);
+        const afterDate = pickInlineDate(propValues(node.properties, 'after'));
+        const beforeDate = pickInlineDate(propValues(node.properties, 'before'));
+        const title = node.title ?? node.name;
+        const chrome = containerChrome({
+            drawn: true,
+            hasTitle: Boolean(title),
+            hasPins: Boolean(afterDate || beforeDate),
+            hasBracket: style.bracket !== 'none',
+        });
+        const firstTrackY = cursor.y + chrome.header + chrome.pad;
         const children: PositionedTrackChild[] = [];
-        let maxRight = startX;
+        // The tracks' span in time: the bracket and body open on the
+        // earliest track start and close on the latest track end, the join
+        // (bars span exactly their dates, specs/true-width-layout.md §3.1).
+        let minTimeLeft = Number.POSITIVE_INFINITY;
+        let maxTimeRight = Number.NEGATIVE_INFINITY;
         let accumulatedHeight = 0;
 
         // Each child of a parallel block lives on its own sub-track,
@@ -61,47 +74,65 @@ export class ParallelNode {
         for (const child of node.content) {
             if (child.$type === 'DescriptionDirective') continue;
             ctx.currentFlowKey = `${previousFlowKey}/par:${parId}#${childIndex}`;
-            const subCursor = deps.newCursor(startX, startY + accumulatedHeight);
-            const positioned = deps.sequenceOne(
+            const subCursor = newCursor(startX, firstTrackY + accumulatedHeight);
+            const positioned = helpers.sequenceOne(
                 child as ItemDeclaration | GroupBlock,
                 subCursor,
                 ctx,
             );
             children.push(positioned);
             accumulatedHeight += Math.max(ctx.bandScale.step(), subCursor.height);
-            maxRight = Math.max(maxRight, subCursor.maxX);
+            minTimeLeft = Math.min(minTimeLeft, subCursor.startX);
+            maxTimeRight = Math.max(maxTimeRight, subCursor.x);
             childIndex++;
         }
         ctx.currentFlowKey = previousFlowKey;
+        if (children.length === 0) {
+            // Under `show` an empty box still opens on a working day.
+            minTimeLeft = ctx.scale.showsNonWorking ? ctx.scale.startX(startX) : startX;
+            maxTimeRight = minTimeLeft;
+        }
 
+        // Each track's height carries the inter-row gap below it; the body
+        // ends `pad` below the last track's painted bottom, and the cursor
+        // adds the gap back after the body.
+        const step = ctx.bandScale.step();
+        const interRowGap = step - ctx.bandScale.bandwidth();
+        const contentHeight = Math.max(step, accumulatedHeight) - interRowGap;
         const box: BoundingBox = {
-            x: startX,
-            y: startY,
-            width: maxRight - startX,
-            height: accumulatedHeight,
+            x: minTimeLeft,
+            y: cursor.y,
+            width: maxTimeRight - minTimeLeft,
+            height: chrome.header + chrome.pad + contentHeight + chrome.pad,
         };
 
-        cursor.x = maxRight + TRACK_BLOCK_TAIL_GUTTER_PX;
-        cursor.maxX = Math.max(cursor.maxX, cursor.x);
-        cursor.height = Math.max(cursor.height, accumulatedHeight);
+        // No tail gutter: the parallel joins on its latest track end in
+        // time, as engine C does (specs/scheduler-unification.md §8
+        // decisions 6, 8).
+        cursor.startX = box.x;
+        cursor.x = maxTimeRight;
+        cursor.height = Math.max(cursor.height, box.height + interRowGap);
 
         const id = node.name;
+        // `after:` the parallel is a time path: its latest track end.
         if (id) {
             ctx.entityLeftEdges.set(id, box.x);
-            ctx.entityRightEdges.set(id, box.x + box.width);
+            ctx.entityRightEdges.set(id, maxTimeRight);
         }
 
         const inlineDatePins = computeContainerInlineDatePins({
             box,
-            afterDate: pickInlineDate(propValues(node.properties, 'after')),
-            beforeDate: pickInlineDate(propValues(node.properties, 'before')),
+            afterDate,
+            beforeDate,
+            title,
         });
 
         return {
             kind: 'parallel',
             id,
-            title: node.title ?? node.name,
+            title,
             box,
+            headerHeight: chrome.header,
             children,
             style,
             inlineDatePins: inlineDatePins.length > 0 ? inlineDatePins : undefined,

package/src/nodes/region-markers.ts

@@ -0,0 +1,194 @@
+// Region markers — an isolated region's own anchors and milestones, drawn
+// in a marker row of the region's own, under its label tab
+// (specs/rendering.md § Included Roadmap Region). The row packs with the
+// host's packer and label rules, bounded by the region's dashed border
+// instead of the chart; the region's lanes move down by its height, and
+// each cut line stops at the region's last lane.
+
+import type { AnchorDeclaration, IsolatedRegion } from '@nowline/core';
+import type { LayoutContext } from '../layout-context.js';
+import { estimateTextWidth } from '../text-measure.js';
+import type { PositionedAnchor, PositionedIncludeRegion, PositionedMilestone } from '../types.js';
+import { buildAnchors } from './anchor-node.js';
+import {
+    datePinnedMarkerEntries,
+    type MarkerEntity,
+    markerArrows,
+    markerLabelsRightX,
+    markerRowPlacements,
+    packMarkerRow,
+} from './marker-band.js';
+import { MARKER_ROW_PITCH_PX } from './marker-geometry.js';
+import { buildMilestones, type MilestonePlacement, positionMilestones } from './milestone-node.js';
+
+/**
+ * How far a region's marker labels stay inside the region box on either
+ * side: the renderer's 8 px border inset plus 8 px of air.
+ */
+export const REGION_MARKER_INSET_X_PX = 16;
+
+/** The region marker band's top, below the region's top border. */
+const REGION_MARKER_BAND_TOP_PX = 8;
+
+/** Air between the region marker band and the region's first lane. */
+const REGION_MARKER_BAND_GAP_PX = 6;
+
+/** A region's placed markers and how far its lanes move down for them. */
+export interface RegionMarkers {
+    anchors: PositionedAnchor[];
+    milestones: PositionedMilestone[];
+    /** The lanes' shift: 0 when the region has no marker to draw. */
+    laneShift: number;
+}
+
+/**
+ * Place `region`'s anchors and milestones once its lanes are laid out
+ * from `lanesTopY` down to `lanesBottomY`, inside a region whose top
+ * border is at `regionTopY`. The pack is bounded by the region's left
+ * inset and by `chartRightX` (the canvas before finalize grows it) less
+ * the right inset; a label that fits on neither side packs to the right
+ * and finalize f3 grows the canvas for it (`regionMarkerCanvasRightX`).
+ * The caller shifts the lanes by `laneShift`.
+ */
+export function placeRegionMarkers(
+    region: IsolatedRegion,
+    ctx: LayoutContext,
+    regionTopY: number,
+    lanesTopY: number,
+    lanesBottomY: number,
+    chartRightX: number,
+): RegionMarkers {
+    // A milestone `after:` an anchor reads the anchor's edge. Without waves
+    // the edges are already seeded for the lanes; with waves they are
+    // seeded here, after the lanes, so the lanes still see only the wave
+    // edges.
+    seedRegionAnchorEdges(region.content.anchors, ctx);
+    const placements = buildMilestones(region.content.milestones, ctx);
+    const entries = regionMarkerEntries(region.content.anchors, placements, ctx);
+    if (entries.length === 0) return { anchors: [], milestones: [], laneShift: 0 };
+
+    const leftX = REGION_MARKER_INSET_X_PX;
+    const packed = packMarkerRow(
+        entries,
+        leftX,
+        markerLabelsRightX(
+            entries,
+            leftX,
+            chartRightX - REGION_MARKER_INSET_X_PX,
+            estimateTextWidth,
+        ),
+        estimateTextWidth,
+        markerArrows(placements),
+    );
+    const bandTopY = regionTopY + REGION_MARKER_BAND_TOP_PX;
+    const laneShift =
+        bandTopY + packed.rowCount * MARKER_ROW_PITCH_PX + REGION_MARKER_BAND_GAP_PX - lanesTopY;
+    const cutBottomY = lanesBottomY + laneShift;
+
+    const rows = markerRowPlacements(packed.placements, bandTopY);
+    ctx.markerRowPlacements = rows;
+    ctx.chartTopY = lanesTopY + laneShift;
+    ctx.swimlaneBottomY = cutBottomY;
+    const anchors = buildAnchors(region.content.anchors, ctx, new Set());
+    // Placement read each item predecessor's y before the lanes moved; an
+    // arrow from a region marker starts on its row in `rows`.
+    const milestones = positionMilestones(
+        placements.map((p) => ({
+            ...p,
+            cutTopY: ctx.chartTopY,
+            cutBottomY,
+            slackArrows: p.slackArrows?.map((a) => ('y' in a ? { x: a.x, y: a.y + laneShift } : a)),
+        })),
+        rows,
+    );
+    return { anchors, milestones, laneShift };
+}
+
+/**
+ * The canvas right edge `region`'s marker labels need: a label that fits
+ * on neither side of its marker inside the region's insets grows the
+ * canvas until it fits on the right, the host's marker-row rule. Returns
+ * `chartRightX` when every label fits.
+ */
+export function regionMarkerCanvasRightX(
+    region: PositionedIncludeRegion,
+    chartRightX: number,
+): number {
+    const entries: MarkerEntity[] = [
+        ...(region.anchors ?? []).map((a) => positionedEntry(a, false)),
+        ...(region.milestones ?? []).map((m) => positionedEntry(m, true)),
+    ];
+    if (entries.length === 0) return chartRightX;
+    const rightX = markerLabelsRightX(
+        entries,
+        region.box.x + REGION_MARKER_INSET_X_PX,
+        chartRightX - REGION_MARKER_INSET_X_PX,
+        estimateTextWidth,
+    );
+    return rightX + REGION_MARKER_INSET_X_PX;
+}
+
+/** The right end of `region`'s rightmost marker label, or 0 with none. */
+export function regionMarkerLabelsRightX(region: PositionedIncludeRegion): number {
+    let rightX = 0;
+    for (const m of [...(region.anchors ?? []), ...(region.milestones ?? [])]) {
+        rightX = Math.max(rightX, m.labelBox.x + m.labelBox.width);
+    }
+    return rightX;
+}
+
+/**
+ * The host's marker order: the date-pinned anchors, the dated milestones,
+ * then the after-only ones, so the stable sort in `packMarkerRow` breaks
+ * a tie on x the same way the host's band does.
+ */
+function regionMarkerEntries(
+    anchors: ReadonlyMap<string, AnchorDeclaration>,
+    milestones: readonly MilestonePlacement[],
+    ctx: LayoutContext,
+): MarkerEntity[] {
+    const entries: MarkerEntity[] = datePinnedMarkerEntries(anchors, new Map(), ctx.scale);
+    const milestoneEntry = (m: MilestonePlacement): MarkerEntity => ({
+        id: m.id,
+        centerX: m.slipX ?? m.x,
+        radius: m.radius,
+        title: m.title,
+        fontSize: 10,
+        bold: true,
+        ...(m.slipX !== undefined ? { slipFromX: m.x } : {}),
+    });
+    entries.push(...milestones.filter((m) => m.fixed).map(milestoneEntry));
+    entries.push(...milestones.filter((m) => !m.fixed).map(milestoneEntry));
+    return entries;
+}
+
+function positionedEntry(m: PositionedAnchor | PositionedMilestone, bold: boolean): MarkerEntity {
+    // A slipped milestone's label sits at its slipped diamond.
+    const slipX = 'slip' in m ? m.slip?.x : undefined;
+    return {
+        id: m.id ?? '',
+        centerX: slipX ?? m.center.x,
+        radius: m.radius,
+        title: m.title,
+        fontSize: 10,
+        bold,
+        // The label is forced right of the slipped diamond, as in the pack
+        // (`regionMarkerEntries`) and f3's host entries.
+        ...(slipX !== undefined ? { slipFromX: m.center.x } : {}),
+    };
+}
+
+/**
+ * Seed a region's dated anchors into its context's edge maps at their x on
+ * the host's scale, the way the host seeds its own (`phases/place.ts`).
+ * An anchor outside the date window is skipped, as on the host.
+ */
+export function seedRegionAnchorEdges(
+    anchors: ReadonlyMap<string, AnchorDeclaration>,
+    ctx: LayoutContext,
+): void {
+    for (const e of datePinnedMarkerEntries(anchors, new Map(), ctx.scale)) {
+        ctx.entityLeftEdges.set(e.id, e.centerX);
+        ctx.entityRightEdges.set(e.id, e.centerX);
+    }
+}