@draftably/markdown 0.2.0 → 0.2.2

package/dist/mermaid.js

@@ -61,7 +61,7 @@ async function S() {
   globalThis.fetch = async () => {
     throw Error("Mermaid resource loading is disabled.");
   };
-  const { JSDOM: i } = await import("jsdom"), { createMermaidFlowParser: s, makePlainLabel: e } = await import("./chunks/mermaid-facade-BoLWBerE.js"), { importMermaidFlow: t } = await import("./chunks/mermaid-importer-IVovOQE9.js"), r = new i("<!doctype html><html><body></body></html>", {
+  const { JSDOM: i } = await import("jsdom"), { createMermaidFlowParser: s, makePlainLabel: e } = await import("./chunks/mermaid-facade-BoLWBerE.js"), { importMermaidFlow: t } = await import("./chunks/mermaid-importer-BHKoojYC.js"), r = new i("<!doctype html><html><body></body></html>", {
     url: "https://import.invalid/"
   });
   Object.assign(globalThis, {

package/dist/types/src/dsl/cells.d.ts

@@ -15,6 +15,7 @@ export interface CellInput {
     size?: {
         width: number;
         height?: number;
+        minHeight?: number;
     };
 }
 export interface CellBox {

package/dist/types/src/dsl/compile.d.ts

@@ -1,5 +1,6 @@
 import { type ResolvedAppearance } from '../model/appearance';
 import type { CellsChrome, Lane, SequenceLayout } from '../model/types';
+import { type Planned } from './corridors';
 import { GROUP_HEADER, GROUP_INSET, contentOrigin } from './frame';
 import { type Model, type ModelEdge, type ModelLayout, type ModelObject } from './syntax';
 /** The single render context. Browser window size changes the camera, never the layout. */
@@ -44,6 +45,8 @@ export interface Diagnostic {
 /** A connection as the file declares it, plus the lane a fold's wrap edge returns along. */
 export interface SceneEdge extends ModelEdge {
     lane?: Lane;
+    /** A forward line's route, planned from its scope's ranks and corridors (`planRoutes`). */
+    plan?: Planned;
     /** A sequence message: the height of its row; it is drawn straight between lifelines there. */
     row?: number;
 }
@@ -96,11 +99,12 @@ export declare function layoutFor(m: Model, scope: string): ModelLayout;
 /**
  * Size of a node: its requested size, or the default width with a height that fits the title in
  * the theme's type and padding. A requested size is kept exactly; `overflow` reports a title that
- * no longer fits in it.
+ * no longer fits in it. With `height=auto`, `min-height` is a floor under the title's height.
  */
 export declare function leafSize(o: ModelObject, size: {
     width: number;
     height?: number;
+    minHeight?: number;
 } | undefined, look: ResolvedAppearance): {
     w: number;
     h: number;
@@ -149,6 +153,16 @@ export declare function crossings(paths: Array<Array<{
 }>>): number;
 /** The order of up to six items that scores fewest crossings; the first such, from `items`. */
 export declare function fewestCrossings<T>(items: T[], score: (order: T[]) => number): T[];
+/**
+ * The corridors a `flow` scope keeps for lines that skip ranks: the ranks with their stand-ins,
+ * each line's stand-ins by its index in the scope's pairs, and each stand-in's place across the
+ * run, in the scope's coordinates.
+ */
+export interface Corridors {
+    order: string[][];
+    chains: Map<number, string[]>;
+    across: Map<string, number>;
+}
 /**
  * Lay out a model. `arranged` holds world positions from layout engines; scopes that an engine
  * governs take their children's relative placement from it instead of their built-in recipe.

package/dist/types/src/dsl/corridors.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Routes for a `flow` scope's forward lines, planned from its ranks as a layered layout routes its
+ * edges: out of the source's trailing side, along a track in each gap the line turns in, down a
+ * corridor through each rank it skips, and into the target's leading side. The ranks' order already
+ * keeps crossings few, so the plan only has to place ports and order each gap's tracks. The router
+ * takes a planned route as it is when it clears every box.
+ */
+import type { Point, Rect } from '../model/types';
+export interface PlanLine {
+    id: string;
+    /** Source, the stand-ins of the ranks it skips, target. */
+    chain: string[];
+}
+export interface Planned {
+    points: Point[];
+    fromOffset: number;
+    toOffset: number;
+}
+/**
+ * Space between ports on one side and between neighbouring tracks in a gap, as the router keeps
+ * them: ports `max(portGap, edgeGap)` apart and tracks `edgeGap` apart.
+ */
+export interface Spacing {
+    port: number;
+    track: number;
+}
+/**
+ * Plans each line of `lines`. `order` is the ranks with stand-ins, `box` each real member's drawn
+ * box and `across` each stand-in's place across the run, all in drawing coordinates. Lines that
+ * cannot be planned (a member without a box) are left out.
+ */
+export declare function planRoutes(axis: 'down' | 'right', order: string[][], lines: PlanLine[], box: (id: string) => Rect | undefined, across: (id: string) => number | undefined, spacing?: Spacing): Map<string, Planned>;
+/**
+ * The room each gap between ranks needs for the tracks `planRoutes` lays in it: a standoff from
+ * the boxes either side and a pitch between tracks, by gap index; a gap with no track is absent.
+ * `box` may be a member's slot: only its place across the run counts.
+ */
+export declare function trackRoom(axis: 'down' | 'right', order: string[][], lines: PlanLine[], box: (id: string) => Rect | undefined, across: (id: string) => number | undefined, spacing?: Spacing): number[];

package/dist/types/src/dsl/legend-notes.d.ts

@@ -1,3 +1,17 @@
+/**
+ * `check` advice on the key and the prose round a drawing: a key that leaves a color or a line
+ * style unexplained, a `legend` swatch drawn in a shade that no node of its family uses, and
+ * heading prose that the drawing should say instead.
+ */
+import { type Shade } from '../model/appearance';
 import type { Diagnostic } from './compile';
 import type { Model } from './syntax';
 export declare function legendNotes(m: Model): Diagnostic[];
+/**
+ * The shade a `legend family` swatch draws when its line sets none: what the family's nodes draw.
+ * When no node names the family and its nodes are all member cards (they inherit it from a group
+ * on a quiet surface shade), that is the member card's shade; otherwise it is a colored node's.
+ */
+export declare function legendShade(m: Model, family: string): Shade;
+/** Give each `legend family` line with no `shade=` the shade its family's nodes draw. */
+export declare function settleLegendShades(m: Model): void;

package/dist/types/src/dsl/syntax.d.ts

@@ -210,11 +210,13 @@ export type Hint = {
     line: number;
 }
 /** `height` is unset for `height=auto`: the title's height at that width, as without a size. */
+/** `minHeight` is a floor under `height=auto`, for a host that draws more than the title. */
  | {
     type: 'size';
     id: string;
     width: number;
     height?: number;
+    minHeight?: number;
     line: number;
 };
 export type Strength = 'prefer' | 'required';

package/dist/types/src/model/appearance.d.ts

@@ -18,6 +18,12 @@ export type Shade = (typeof SHADES)[number];
 export declare const isShade: (n: unknown) => n is Shade;
 /** Shade of a node that names a color without a shade. */
 export declare const NODE_SHADE: Shade;
+/**
+ * Shade of a member card: a node drawn in its container's family with no shade of its own. It is
+ * the palest stop on the canvas side of the frame (50 in light themes, 950 in dark ones), so the
+ * card stands apart from its frame by fill and keeps the family's outline and ink.
+ */
+export declare const memberShadeFor: (theme: ThemeId) => Shade;
 /**
  * Shade of a group that names a color without a shade. Groups are quiet surfaces behind nodes, so
  * this is a pale shade in light themes and a deep one in dark themes; the scale itself never flips.
@@ -148,6 +154,8 @@ interface Preset {
     hues?: Partial<Record<string, [number, number]>>;
 }
 export declare const PRESETS: Record<ThemeId, Preset>;
+/** `a` moved toward `b` by `t` (0–1), in sRGB. */
+export declare function mixColors(a: string, b: string, t: number): string;
 export declare function contrast(a: string, b: string): number;
 /** Contrast targets (WCAG ratios) every generated color meets. */
 export declare const CONTRAST: {
@@ -184,6 +192,8 @@ export interface ResolvedAppearance {
     radius: number;
     shadow: boolean;
     title: TypeProfile;
+    /** A node title's detail lines (after its first `\n`): a step smaller and lighter. */
+    detail: TypeProfile;
     groupTitle: TypeProfile;
     annotation: TypeProfile;
     /** Space above a group's content; the group title sits in it. */
@@ -204,6 +214,15 @@ export declare function resolveAppearance(appearance?: DiagramAppearance): Resol
  * default surface; the file parser reports them before they get here.
  */
 export declare function swatchFor(r: ResolvedAppearance, family: string | undefined, shade: Shade | undefined, kind?: 'node' | 'group'): Swatch;
+/**
+ * The quiet panel behind notes and a sequence diagram: slate 50 in light themes, and the theme's
+ * own group surface in dark ones, so the theme's text ink reads on it.
+ */
+export declare const panelSwatch: (r: ResolvedAppearance) => Swatch;
+/** Bands and dividers drawn over that panel. */
+export declare const bandSwatch: (r: ResolvedAppearance) => Swatch;
+/** Ink for a link in a note or footnote, held to 4.5:1 on `against`. */
+export declare const linkInk: (r: ResolvedAppearance, against: string) => string;
 /** Shades a family defines, in numeric order. */
 export declare const shadesOf: (r: ResolvedAppearance, family: string) => Shade[];
 export {};

package/dist/types/src/model/labels.d.ts

@@ -12,10 +12,25 @@ export interface TitleArea {
     maxHeight: number;
 }
 export declare function titleArea(shape: ShapeKind, w: number, h: number, r: ResolvedAppearance, icon?: boolean): TitleArea;
-/** Height a shape needs for `lines` title lines; never less than `base`. */
-export declare function titleHeight(shape: ShapeKind, lines: number, base: number, r: ResolvedAppearance): number;
-/** A shape's title in balanced lines no wider than `width` (see `wrapLines`). */
-export declare const wrapTitle: (text: string, width: number, r: ResolvedAppearance) => string[];
+/** Height a shape needs for a title block `text` px tall; never less than `base`. */
+export declare function titleHeight(shape: ShapeKind, text: number, base: number, r: ResolvedAppearance): number;
+/** One line of a shape's title: part of its name, or of its detail. */
+export interface TitleLine {
+    text: string;
+    /** A detail line, from the text after the title's first `\n`, drawn in `r.detail`. */
+    detail: boolean;
+}
+/**
+ * A shape's title in balanced lines no wider than `width` (see `wrapLines`). The text before the
+ * first `\n` is the name, in the title type; the rest is detail, in the smaller detail type.
+ */
+export declare function wrapTitle(text: string, width: number, r: ResolvedAppearance): TitleLine[];
+/** The type a title line is set in. */
+export declare const lineType: (l: TitleLine, r: ResolvedAppearance) => TypeProfile;
+/** Height of a block of title lines. */
+export declare const textHeight: (lines: TitleLine[], r: ResolvedAppearance) => number;
+/** Each line's centre, measured from the middle of the block. */
+export declare function lineOffsets(lines: TitleLine[], r: ResolvedAppearance): number[];
 /**
  * Line width for a diamond's title, `s` its side. A text block W wide and H tall fits inside a
  * square diamond when W + H <= s, so this takes the widest measure whose wrapped lines still fit:
@@ -37,9 +52,10 @@ export interface NodeLabel {
     y: number;
     width: number;
     height: number;
-    lines: string[];
+    lines: TitleLine[];
+    /** Each line's centre, relative to `y`. */
+    offsets: number[];
     mode: LabelMode;
-    lineHeight: number;
     leader: boolean;
 }
 /** Where a shape's title is drawn, relative to the shape. */

package/dist/types/src/model/types.d.ts

@@ -93,6 +93,15 @@ export interface EdgeLayout {
     toOffset?: number;
     /** A sequence message: drawn straight between the two lifelines at this height, not routed. */
     row?: number;
+    /**
+     * Set by the compiler for a forward line in a `flow` scope: its route planned from the ranks.
+     * The quick router takes it as it is when it clears every box.
+     */
+    plan?: {
+        points: Point[];
+        fromOffset: number;
+        toOffset: number;
+    };
 }
 /**
  * A channel between two bands of a fold: a level line at `y`, or an upright one at `x`. With

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@draftably/markdown",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Build static SVG diagram assets from Markdown draft fences.",
   "license": "MIT",
   "type": "module",
@@ -35,7 +35,7 @@
   "dependencies": {
     "jsdom": "26.1.0",
     "mermaid": "12.2.0",
-    "@draftably/runtime": "0.2.0"
+    "@draftably/runtime": "0.4.0"
   },
   "engines": {
     "node": ">=22.21.0"