@weasel-js/diagram 1.13.0 → 1.14.1

package/dist/labelTrait-BBjRgxbz.d.ts

@@ -0,0 +1,44 @@
+import { Vec2 } from '@weasel-js/core/math';
+
+/**
+ * The label trait: where along its edge a label sits. Data only — placing the
+ * label on the route is `label`'s job, so layout can read one without
+ * reaching the scene.
+ */
+
+/** Where along an edge a label sits. */
+interface DiagramLabel {
+    /** `'start'`, `'mid'` and `'end'` are 0, 0.5 and 1; a number is that
+     *  fraction of the route's length. `{ near }` is the point on the route
+     *  nearest `near`, in world coordinates — where `layered` leaves a label
+     *  room — so a bend added or removed elsewhere leaves the label on the
+     *  stretch it was on. */
+    at: 'start' | 'mid' | 'end' | number | {
+        near: Vec2;
+    };
+    /** World units between the route and the label's near side, to the **left
+     *  of the direction of travel** — above a left-to-right edge. Default 0,
+     *  which centers the label on the line. */
+    offset?: number;
+    /** Where label placement moved it, off a station something covered:
+     *  `at` a fraction of the route's length, `offset` as above. Read in place
+     *  of `at` and `offset`, which stay the author's preference. Written only
+     *  by placement (`installLabelPlacement`). */
+    placed?: LabelSpot;
+    /** `false` keeps placement from ever moving this label. */
+    dodge?: false;
+}
+/** A station placement chose: a fraction of the route's length, and the
+ *  offset from the line. */
+interface LabelSpot {
+    at: number;
+    offset: number;
+}
+/** Where an edge label sits when neither the edge nor the scene says. */
+declare const LABEL_PLACEMENT: DiagramLabel;
+/** The label trait on a node's data, or `null`. */
+declare function diagramLabelOf(node: {
+    data: unknown;
+}): DiagramLabel | null;
+
+export { type DiagramLabel as D, type LabelSpot as L, LABEL_PLACEMENT as a, diagramLabelOf as d };

package/dist/layout.d.ts

@@ -1,5 +1,6 @@
-export { t as BodyFloor, B as BodySpec, m as Bounds, w as DEFAULT_HOP_SIZE, x as DEFAULT_NODE_GAP, y as DEFAULT_RANK_GAP, c as DiagramLabel, f as DiagramNode, E as EdgeHop, H as EdgeLabelRoom, G as Graph, I as GraphEdge, J as GraphGroup, K as GraphNode, Q as HOPS_DOC_KEY, T as HopsDocValue, l as LabelSpot, V as LayoutAxes, q as LayoutDirection, d as LayoutFn, e as LayoutOptions, r as LayoutPlan, p as LayoutPlanner, L as LayoutPorts, n as LayoutResult, M as MeasureRowText, O as Outline, g as Port, P as PortAnchor, W as PortSite, b as PortSpec, a as Row, X as RowBox, Y as RowPort, Z as RowPortBox, R as RowTextStyle, _ as Slot, $ as anchorOffset, a0 as axesFor, a2 as bodyOutline, a4 as boxForContent, a6 as canvasMeasure, a7 as contentBox, ay as extent, ae as graphOrder, ai as layoutBody, aj as layoutRowPorts, ak as measureBody, al as outlinePath, am as packAcross, ao as pinnedSet, ap as planOf, aq as plannerPlan, as as seededOrder, at as settle, au as sizeToBody, aw as translated, ax as untilSettled } from './types-vbW21fHm.js';
-export { e as AVOID_DEFAULTS, f as AvoidEdge, g as AvoidEnd, A as AvoidInput, h as AvoidLabel, i as AvoidObstacle, b as AvoidOptions, j as AvoidPort, a as AvoidRouter, c as AvoidRoutes, k as AvoidUpdateOptions, B as BodyNodeSpec, l as BuildBodyOptions, C as COMPASS, D as DEFAULT_PORTS, m as ForceBody, F as ForceOptions, n as ForceRelaxation, L as LabelPlacements, p as LayeredPlan, q as PORT_LABEL_GAP, r as PerimeterPortLabelBox, s as PlaceLabel, t as PlaceLabelsInput, d as PlaceLabelsOptions, u as PlaceRoute, P as PortsOptions, R as RowNodeData, w as backEdges, x as buildBody, y as chain, z as createAvoidRouter, E as edgeHops, G as footprintNode, H as force, I as forceRelaxation, J as forestOf, K as labelCenter, M as layered, N as layeredPlan, O as marginOf, Q as outlinePolyline, S as placeLabels, T as portLabelBox, V as portOf, W as portSitesOf, X as portsOf, Y as portsOnOutline, Z as ranksByLength, _ as ranksOf, $ as rayHit, a0 as routeHolds, a1 as tree } from './layout.entry-CQoPNfzA.js';
-import '@weasel-js/core/math';
+export { s as BodyFloor, B as BodySpec, k as Bounds, v as BuiltinOutline, x as DEFAULT_HOP_SIZE, y as DEFAULT_NODE_GAP, z as DEFAULT_RANK_GAP, e as DiagramNode, E as EdgeHop, J as EdgeLabelRoom, G as Graph, K as GraphEdge, N as GraphGroup, Q as GraphNode, U as HOPS_DOC_KEY, V as HopsDocValue, W as LayoutAxes, o as LayoutDirection, c as LayoutFn, d as LayoutOptions, p as LayoutPlan, n as LayoutPlanner, L as LayoutPorts, l as LayoutResult, M as MeasureRowText, O as Outline, X as OutlineDef, f as Port, P as PortAnchor, Y as PortSite, b as PortSpec, a as Row, Z as RowBox, _ as RowPort, $ as RowPortBox, R as RowTextStyle, a0 as Slot, a1 as anchorOffset, a2 as axesFor, a4 as bodyOutline, a6 as boxForContent, a8 as canvasMeasure, a9 as contentBox, aB as extent, af as graphOrder, aj as layoutBody, ak as layoutRowPorts, al as measureBody, am as outlineDetail, an as outlinePath, ao as packAcross, aq as pinnedSet, ar as planOf, as as plannerPlan, au as registerOutline, av as seededOrder, aw as settle, ax as sizeToBody, az as translated, aA as untilSettled } from './types-B0n2CNTW.js';
+export { e as AVOID_DEFAULTS, f as AvoidEdge, g as AvoidEnd, A as AvoidInput, h as AvoidLabel, i as AvoidObstacle, b as AvoidOptions, j as AvoidPort, a as AvoidRouter, c as AvoidRoutes, k as AvoidUpdateOptions, B as BodyNodeSpec, l as BuildBodyOptions, C as COMPASS, D as DEFAULT_PORTS, m as ForceBody, F as ForceOptions, n as ForceRelaxation, L as LabelPlacements, p as LayeredPlan, q as PORT_LABEL_GAP, r as PerimeterPortLabelBox, s as PlaceLabel, t as PlaceLabelsInput, d as PlaceLabelsOptions, u as PlaceRoute, P as PortsOptions, R as RowNodeData, w as backEdges, x as buildBody, y as chain, z as createAvoidRouter, E as edgeHops, G as footprintNode, H as force, I as forceRelaxation, J as forestOf, K as labelCenter, M as layered, N as layeredPlan, O as marginOf, Q as outlineFromD, S as outlinePolyline, T as placeLabels, U as portLabelBox, W as portOf, X as portSitesOf, Y as portsOf, Z as portsOnOutline, _ as radial, $ as ranksByLength, a0 as ranksOf, a1 as rayHit, a2 as routeHolds, a3 as subtreeBlocks, a4 as tree } from './layout.entry-Ca6pVvqo.js';
+export { D as DiagramLabel, L as LabelSpot } from './labelTrait-BBjRgxbz.js';
 import '@weasel-js/geom';
+import '@weasel-js/core/math';
 import '@weasel-js/simulation';

package/dist/{layout.entry-CQoPNfzA.d.ts → layout.entry-Ca6pVvqo.d.ts}

@@ -1,6 +1,15 @@
-import { m as Bounds, b as PortSpec, g as Port, N as GroupInset, f as DiagramNode, M as MeasureRowText, X as RowBox, Z as RowPortBox, B as BodySpec, K as GraphNode, i as DiagramNodeReader, h as DiagramNodeLike, c as DiagramLabel, E as EdgeHop, l as LabelSpot, e as LayoutOptions, G as Graph, n as LayoutResult, d as LayoutFn, L as LayoutPorts, O as Outline } from './types-vbW21fHm.js';
+import { k as Bounds, X as OutlineDef, b as PortSpec, f as Port, T as GroupInset, e as DiagramNode, M as MeasureRowText, Z as RowBox, $ as RowPortBox, B as BodySpec, Q as GraphNode, h as DiagramNodeReader, g as DiagramNodeLike, E as EdgeHop, d as LayoutOptions, G as Graph, l as LayoutResult, c as LayoutFn, L as LayoutPorts, O as Outline } from './types-B0n2CNTW.js';
 import { Vec2, PoseDescriptor, Path } from '@weasel-js/core/math';
 import { SimulationNode, createSimulation } from '@weasel-js/simulation';
+import { D as DiagramLabel, L as LabelSpot } from './labelTrait-BBjRgxbz.js';
+
+/** An outline from SVG path data in a unit square — `(0, 0)` the box's
+ *  top-left, `(1, 1)` its bottom-right — stretched over each node's bounds.
+ *  `content` is in the same unit square. */
+declare function outlineFromD(d: string, opts?: {
+    detail?: string;
+    content?: Bounds;
+}): OutlineDef;
 
 /**
  * Perimeter port labels: where the text naming a port is drawn, and how far
@@ -581,11 +590,23 @@ interface Forest {
  *  node ended up whose child" is the question anyone debugging a tree layout
  *  asks first. */
 declare function forestOf(graph: Graph, crossAxis: 'x' | 'y'): Forest;
+/** Subtrees packed as solid blocks on one axis. `span` is how much room a node's
+ *  whole subtree takes: its children's blocks side by side, or the node itself
+ *  when that is wider. `lay` writes the low corner of every node in a subtree
+ *  whose block starts at `from`, each parent centered over its children. */
+declare function subtreeBlocks(children: ReadonlyMap<string, readonly GraphNode[]>, axis: 'x' | 'y', gap: number): {
+    span(node: GraphNode): number;
+    lay(node: GraphNode, from: number, into: Map<string, number>): void;
+};
 /** The hierarchy layout: each parent centered over its children's block, one
  *  rank per depth. A graph that is not a tree lays out as the forest
  *  {@link forestOf} reads from it. */
 declare const tree: LayoutFn;
 
+/** The mind-map layout: the first root in the middle, its branches balanced
+ *  to its right and its left, any further trees stacked below. */
+declare const radial: LayoutFn;
+
 /** The outline as a closed polyline: `[x0, y0, x1, y1, …]`. */
 declare function outlinePolyline(outline: Outline, bounds: Bounds): number[];
 /**
@@ -611,4 +632,4 @@ declare function rayHit(poly: readonly number[], center: {
  */
 declare function portsOnOutline(ports: readonly Port[], outline: Outline, bounds: Bounds): Port[];
 
-export { rayHit as $, type AvoidInput as A, type BodyNodeSpec as B, COMPASS as C, DEFAULT_PORTS as D, edgeHops as E, type ForceOptions as F, footprintNode as G, force as H, forceRelaxation as I, forestOf as J, labelCenter as K, type LabelPlacements as L, layered as M, layeredPlan as N, marginOf as O, type PortsOptions as P, outlinePolyline as Q, type RowNodeData as R, placeLabels as S, portLabelBox as T, portLabelsOf as U, portOf as V, portSitesOf as W, portsOf as X, portsOnOutline as Y, ranksByLength as Z, ranksOf as _, type AvoidRouter as a, routeHolds as a0, tree as a1, type AvoidOptions as b, type AvoidRoutes as c, type PlaceLabelsOptions as d, AVOID_DEFAULTS as e, type AvoidEdge as f, type AvoidEnd as g, type AvoidLabel as h, type AvoidObstacle as i, type AvoidPort as j, type AvoidUpdateOptions as k, type BuildBodyOptions as l, type ForceBody as m, type ForceRelaxation as n, type Forest as o, type LayeredPlan as p, PORT_LABEL_GAP as q, type PerimeterPortLabelBox as r, type PlaceLabel as s, type PlaceLabelsInput as t, type PlaceRoute as u, type PortLabelPlacement as v, backEdges as w, buildBody as x, chain as y, createAvoidRouter as z };
+export { ranksByLength as $, type AvoidInput as A, type BodyNodeSpec as B, COMPASS as C, DEFAULT_PORTS as D, edgeHops as E, type ForceOptions as F, footprintNode as G, force as H, forceRelaxation as I, forestOf as J, labelCenter as K, type LabelPlacements as L, layered as M, layeredPlan as N, marginOf as O, type PortsOptions as P, outlineFromD as Q, type RowNodeData as R, outlinePolyline as S, placeLabels as T, portLabelBox as U, portLabelsOf as V, portOf as W, portSitesOf as X, portsOf as Y, portsOnOutline as Z, radial as _, type AvoidRouter as a, ranksOf as a0, rayHit as a1, routeHolds as a2, subtreeBlocks as a3, tree as a4, type AvoidOptions as b, type AvoidRoutes as c, type PlaceLabelsOptions as d, AVOID_DEFAULTS as e, type AvoidEdge as f, type AvoidEnd as g, type AvoidLabel as h, type AvoidObstacle as i, type AvoidPort as j, type AvoidUpdateOptions as k, type BuildBodyOptions as l, type ForceBody as m, type ForceRelaxation as n, type Forest as o, type LayeredPlan as p, PORT_LABEL_GAP as q, type PerimeterPortLabelBox as r, type PlaceLabel as s, type PlaceLabelsInput as t, type PlaceRoute as u, type PortLabelPlacement as v, backEdges as w, buildBody as x, chain as y, createAvoidRouter as z };

package/dist/layout.js

@@ -1,5 +1,5 @@
 import './chunk-WDIE35AK.js';
-export { AVOID_DEFAULTS, DEFAULT_HOP_SIZE, HOPS_DOC_KEY, createAvoidRouter, edgeHops, placeLabels } from './chunk-Y72FK3Y7.js';
-export { COMPASS, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, PORT_LABEL_GAP, anchorOffset, axesFor, backEdges, bodyOutline, boxForContent, buildBody, canvasMeasure, chain, contentBox, extent, footprintNode, force, forceRelaxation, forestOf, graphOrder, labelCenter, layered, layeredPlan, layoutBody, layoutRowPorts, marginOf, measureBody, outlinePath, outlinePolyline, packAcross, pinnedSet, planOf, plannerPlan, portLabelBox, portOf, portSitesOf, portsOf, portsOnOutline, ranksByLength, ranksOf, rayHit, routeHolds, seededOrder, settle, sizeToBody, translated, tree, untilSettled } from './chunk-L4H444QI.js';
+export { AVOID_DEFAULTS, DEFAULT_HOP_SIZE, HOPS_DOC_KEY, createAvoidRouter, edgeHops, placeLabels, radial } from './chunk-5VNPLOIX.js';
+export { COMPASS, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, PORT_LABEL_GAP, anchorOffset, axesFor, backEdges, bodyOutline, boxForContent, buildBody, canvasMeasure, chain, contentBox, extent, footprintNode, force, forceRelaxation, forestOf, graphOrder, labelCenter, layered, layeredPlan, layoutBody, layoutRowPorts, marginOf, measureBody, outlineDetail, outlineFromD, outlinePath, outlinePolyline, packAcross, pinnedSet, planOf, plannerPlan, portLabelBox, portOf, portSitesOf, portsOf, portsOnOutline, ranksByLength, ranksOf, rayHit, registerOutline, routeHolds, seededOrder, settle, sizeToBody, subtreeBlocks, translated, tree, untilSettled } from './chunk-VB6HUKNG.js';
 //# sourceMappingURL=layout.js.map
 //# sourceMappingURL=layout.js.map

package/dist/{stageTypes-DvnR8cKQ.d.ts → stageTypes-UiO25hcn.d.ts}

@@ -1,5 +1,6 @@
 import { Page } from '@weasel-js/core';
 import { Vec2 } from '@weasel-js/core/math';
+import { D as DiagramLabel } from './labelTrait-BBjRgxbz.js';
 
 /** An effects pipeline as plain data. It says what is wired to what and
  *  nothing about how any of it is drawn. */
@@ -44,6 +45,9 @@ interface EffectPort {
     /** Default the id. */
     label?: string;
     type: string;
+    /** An input that takes any number of wires, which a runner combines: the
+     *  audio runner sums them, as Web Audio does. Default one wire. */
+    many?: boolean;
 }
 /** A connection from one stage's output to another stage's input. */
 interface EffectWire {
@@ -147,6 +151,9 @@ interface EffectDoc {
     routes?: Readonly<Record<string, readonly Vec2[]>>;
     /** The routes a person drew under `rack` and `lanes`, by look, then by wire id. */
     lookRoutes?: LookRoutes;
+    /** Where a person put each wire's label, by wire id. Along the route and
+     *  off it, so it holds under every look, and over where a look puts it. */
+    labels?: Readonly<Record<string, DiagramLabel>>;
     /** Each group's box under `nodeGraph`, by group id, beside the pipeline as
      *  `places` is. A group with none fits its members. */
     groupBoxes?: Readonly<Record<string, EffectBox>>;

package/dist/{types-vbW21fHm.d.ts → types-B0n2CNTW.d.ts}

@@ -1,17 +1,5 @@
-import { Path, Vec2, PoseDescriptor } from '@weasel-js/core/math';
 import * as _weasel_js_geom from '@weasel-js/geom';
-
-/**
- * The shapes a built body can wear, as paths in the node's bounds.
- *
- * These are the flowchart vocabulary — a decision is a diamond, an I/O step a
- * parallelogram, a terminator a stadium, a demultiplexer a trapezoid, a preparation step a hexagon,
- * a connector an ellipse — plus `'rect'` for everything else and
- * a `Path` escape hatch for a shape the vocabulary does not have. The path is
- * built in world coordinates from the bounds it is given, the same way the
- * kit's own `clipFromPose` factories are; a custom `Path` is drawn in a unit
- * square and stretched over them, as a mark is.
- */
+import { Path, Vec2, PoseDescriptor } from '@weasel-js/core/math';
 
 /** An axis-aligned box. This is `PoseDescriptor.getBounds`'s return shape
  *  minus its optional `rotation`, deliberately: an outline is built in the
@@ -23,80 +11,98 @@ interface Bounds {
     width: number;
     height: number;
 }
-/** A named flowchart shape, or a path a consumer built themselves in a unit
- *  square — `(0, 0)` the box's top-left, `(1, 1)` its bottom-right — so it
- *  follows its node wherever layout or a drag puts it. */
-type Outline = 'rect' | 'diamond' | 'stadium' | 'ellipse' | 'parallelogram' | 'trapezoid' | 'hexagon' | Path;
+interface Size {
+    width: number;
+    height: number;
+}
+/** A named outline: how its shape is built in a node's bounds, and where the
+ *  node's rows may sit inside it. */
+interface OutlineDef {
+    /** Filled and stroked; also the node's silhouette for picking and clipping. */
+    path(bounds: Bounds): Path;
+    /** Stroked only, over the fill: a cylinder's front rim, a note's fold. */
+    detail?(bounds: Bounds): Path;
+    /** The largest box rows can occupy without leaving the shape. Default the bounds. */
+    content?(bounds: Bounds): Bounds;
+    /** The inverse of `content`: a box whose content is at least `content`. Default the content size. */
+    boxForContent?(content: Size): Size;
+}
+
+declare const BUILTINS: {
+    component: OutlineDef;
+    doubleRect: OutlineDef;
+    event: OutlineDef;
+    intermediateEvent: OutlineDef;
+    exclusiveGateway: OutlineDef;
+    parallelGateway: OutlineDef;
+    inclusiveGateway: OutlineDef;
+    eventGateway: OutlineDef;
+    subprocess: OutlineDef;
+    server: OutlineDef;
+    router: OutlineDef;
+    switch: OutlineDef;
+    firewall: OutlineDef;
+    laptop: OutlineDef;
+    desktop: OutlineDef;
+    phone: OutlineDef;
+    printer: OutlineDef;
+    user: OutlineDef;
+    globe: OutlineDef;
+    cylinder: OutlineDef;
+    document: OutlineDef;
+    note: OutlineDef;
+    folder: OutlineDef;
+    cube: OutlineDef;
+    roundRect: OutlineDef;
+    triangle: OutlineDef;
+    octagon: OutlineDef;
+    cloud: OutlineDef;
+    actor: OutlineDef;
+    doubleEllipse: OutlineDef;
+    rect: OutlineDef;
+    diamond: OutlineDef;
+    stadium: OutlineDef;
+    ellipse: OutlineDef;
+    parallelogram: OutlineDef;
+    trapezoid: OutlineDef;
+    hexagon: OutlineDef;
+};
+/** A name the kit itself registers. */
+type BuiltinOutline = keyof typeof BUILTINS;
+/** Register `def` under `name`, shadowing any definition already there.
+ *  Returns the disposer. */
+declare function registerOutline(name: string, def: OutlineDef): () => void;
+
+/**
+ * The shapes a built body can wear, as paths in the node's bounds.
+ *
+ * A name resolves through the outline table (`outlines/table.ts`), which
+ * holds the built-ins and whatever `registerOutline` adds. A `Path` is the
+ * escape hatch for a one-off shape: drawn in a unit square and stretched over
+ * the bounds, as a mark is. Paths are built in world coordinates from the
+ * bounds, the same way the kit's own `clipFromPose` factories are.
+ */
+
+/** A registered outline's name, or a path a consumer built themselves in a
+ *  unit square — `(0, 0)` the box's top-left, `(1, 1)` its bottom-right — so
+ *  it follows its node wherever layout or a drag puts it. */
+type Outline = BuiltinOutline | (string & {}) | Path;
 /** The path `outline` describes inside `bounds`. A zero-area box gives a
  *  zero-area rect rather than a degenerate polygon. */
 declare function outlinePath(outline: Outline, bounds: Bounds): Path;
+/** The strokes `outline` draws over its fill — a cylinder's rim, a note's
+ *  fold — or null when it has none. */
+declare function outlineDetail(outline: Outline, bounds: Bounds): Path | null;
 /**
  * The largest axis-aligned box a shape's content can occupy without leaving
  * the shape. Rows lay out in here, not in the bounds — a diamond's corners and
  * a parallelogram's lean are outside its own box, and a label placed against
  * the bounding box lands there and gets clipped away by the silhouette.
- *
- * Conservative rather than exact: the inscribed rect of a rhombus is exact,
- * and a stadium reports the flat span between its rounded ends, which gives up
- * a little height near them.
  */
 declare function contentBox(outline: Outline, bounds: Bounds): Bounds;
-/**
- * The box whose {@link contentBox} is at least `content` — the inverse, for
- * sizing a node to what its rows measured.
- *
- * The stadium case is the only inexact one: its inset depends on the height it
- * is solving for, so it assumes the wide orientation and adds one height's
- * worth of end caps.
- */
-declare function boxForContent(outline: Outline, content: {
-    width: number;
-    height: number;
-}): {
-    width: number;
-    height: number;
-};
-
-/**
- * The label trait: where along its edge a label sits. Data only — placing the
- * label on the route is `label`'s job, so layout can read one without
- * reaching the scene.
- */
-
-/** Where along an edge a label sits. */
-interface DiagramLabel {
-    /** `'start'`, `'mid'` and `'end'` are 0, 0.5 and 1; a number is that
-     *  fraction of the route's length. `{ near }` is the point on the route
-     *  nearest `near`, in world coordinates — where `layered` leaves a label
-     *  room — so a bend added or removed elsewhere leaves the label on the
-     *  stretch it was on. */
-    at: 'start' | 'mid' | 'end' | number | {
-        near: Vec2;
-    };
-    /** World units between the route and the label's near side, to the **left
-     *  of the direction of travel** — above a left-to-right edge. Default 0,
-     *  which centers the label on the line. */
-    offset?: number;
-    /** Where label placement moved it, off a station something covered:
-     *  `at` a fraction of the route's length, `offset` as above. Read in place
-     *  of `at` and `offset`, which stay the author's preference. Written only
-     *  by placement (`installLabelPlacement`). */
-    placed?: LabelSpot;
-    /** `false` keeps placement from ever moving this label. */
-    dodge?: false;
-}
-/** A station placement chose: a fraction of the route's length, and the
- *  offset from the line. */
-interface LabelSpot {
-    at: number;
-    offset: number;
-}
-/** Where an edge label sits when neither the edge nor the scene says. */
-declare const LABEL_PLACEMENT: DiagramLabel;
-/** The label trait on a node's data, or `null`. */
-declare function diagramLabelOf(node: {
-    data: unknown;
-}): DiagramLabel | null;
+/** The box whose {@link contentBox} is at least `content` — the inverse, for
+ *  sizing a node to what its rows measured. */
+declare function boxForContent(outline: Outline, content: Size): Size;
 
 /**
  * Reading the `DiagramNode` trait off a scene node.
@@ -517,6 +523,8 @@ interface DiagramContainer {
     /** Its box is fitted to its members each time the diagram is built from data
      *  (`DataContainer` with no `box`), so a move that carries it along is no edit of its own. */
     fitted?: true;
+    /** A container whose members are reordered along this axis (`DataContainer.reorder`). */
+    reorder?: 'x' | 'y';
 }
 type Box = {
     x: number;
@@ -617,16 +625,26 @@ interface DiagramNode {
     ownStyle?: readonly StyleField[];
     /** The parts of its text face the author set by hand, which a theme leaves as they are. */
     ownFont?: readonly FontField[];
-    /** On a built body whose rows are all text: how it stacks them, so it can be laid out again when
-     *  their text changes size. Each row's text node carries its place as `bodyRow`. */
+    /** On a built body whose rows are all text or dividers: how it stacks them, so it can be laid out
+     *  again when their text changes size. Each row's text node carries its place as `bodyRow`. */
     body?: BodyLayout;
 }
-/** How a built body stacks its text rows: the `BodySpec` fields its layout reads, and how many rows. */
+/** How a built body stacks its rows: the `BodySpec` fields its layout reads, and how many rows. */
 interface BodyLayout {
     padding: number;
     gap: number;
     verticalAlign: 'top' | 'center' | 'bottom';
     rows: number;
+    /** Each row's height as last laid out, so the rows can be stacked again at a new size without
+     *  measuring. Absent on a body saved before it was recorded. */
+    heights?: readonly number[];
+    /** The divider rows, by place. The outline painter draws their rules. */
+    dividers?: readonly BodyDivider[];
+}
+/** A divider row of a {@link BodyLayout}: its place among the rows, and its `inset`. */
+interface BodyDivider {
+    index: number;
+    inset?: number;
 }
 /** The group half of a {@link DiagramNode}. */
 interface DiagramGroup {
@@ -689,6 +707,12 @@ type Row =
     height: number;
     width?: number;
     id?: string;
+}
+/** A rule across the content box, drawn in the body's own stroke by the
+ *  outline painter. `inset` stops it that far short of each side. */
+ | {
+    kind: 'divider';
+    inset?: number;
 };
 /** A port declared on a row rather than on the node's perimeter. */
 interface RowPort {
@@ -703,6 +727,7 @@ interface RowTextStyle {
     fontSize?: number;
     fontFamily?: string;
     bold?: boolean;
+    italic?: boolean;
 }
 /** Measures one run of text. Returns its advance width and its line height. */
 type MeasureRowText = (text: string, style: RowTextStyle) => {
@@ -745,6 +770,8 @@ interface RowPortBox extends Bounds {
     /** Position within its own side, top to bottom. */
     index: number;
 }
+/** The height a divider row takes; its rule runs through the middle. */
+declare const DIVIDER_HEIGHT = 4;
 /** Adapts the kit's `measureText` for a caller holding a 2D context. Pass the
  *  same context the renderer measures with, or the floor will not match what
  *  is painted. */
@@ -822,4 +849,4 @@ interface EdgeHop {
     r: number;
 }
 
-export { anchorOffset as $, type DiagramNodeEntry as A, type BodySpec as B, type ContainerRole as C, type DiagramGroup as D, type EdgeHop as E, type FontField as F, type Graph as G, type EdgeLabelRoom as H, type GraphEdge as I, type GraphGroup as J, type GraphNode as K, type LayoutPorts as L, type MeasureRowText as M, type GroupInset as N, type Outline as O, type PortAnchor as P, HOPS_DOC_KEY as Q, type RowTextStyle as R, type StyleField as S, type HopsDocValue as T, LABEL_PLACEMENT as U, type LayoutAxes as V, type PortSite as W, type RowBox as X, type RowPort as Y, type RowPortBox as Z, type Slot as _, type Row as a, axesFor as a0, bodyBox as a1, bodyOutline as a2, bodyTrait as a3, boxForContent as a4, buildGraph as a5, canvasMeasure as a6, contentBox as a7, createDiagramNodes as a8, dataKeyReader as a9, diagramContainerOf as aa, diagramLabelOf as ab, diagramNodeOf as ac, expandGroupEdges as ad, graphOrder as ae, headerBox as af, insetOf as ag, isPinned as ah, layoutBody as ai, layoutRowPorts as aj, measureBody as ak, outlinePath as al, packAcross as am, packClusters as an, pinnedSet as ao, planOf as ap, plannerPlan as aq, rankGaps as ar, seededOrder as as, settle as at, sizeToBody as au, titleIdOf as av, translated as aw, untilSettled as ax, extent as ay, type PortSpec as b, type DiagramLabel as c, type LayoutFn as d, type LayoutOptions as e, type DiagramNode as f, type Port as g, type DiagramNodeLike as h, type DiagramNodeReader as i, type DiagramContainer as j, type ContainerHeader as k, type LabelSpot as l, type Bounds as m, type LayoutResult as n, type GraphSource as o, type LayoutPlanner as p, type LayoutDirection as q, type LayoutPlan as r, type GraphNodeLike as s, type BodyFloor as t, type BuildGraphOptions as u, DEFAULT_GROUP_INSET as v, DEFAULT_HOP_SIZE as w, DEFAULT_NODE_GAP as x, DEFAULT_RANK_GAP as y, DIAGRAM_TRAIT_KEY as z };
+export { type RowPortBox as $, DIAGRAM_TRAIT_KEY as A, type BodySpec as B, type ContainerRole as C, type DiagramGroup as D, type EdgeHop as E, type FontField as F, type Graph as G, DIVIDER_HEIGHT as H, type DiagramNodeEntry as I, type EdgeLabelRoom as J, type GraphEdge as K, type LayoutPorts as L, type MeasureRowText as M, type GraphGroup as N, type Outline as O, type PortAnchor as P, type GraphNode as Q, type RowTextStyle as R, type StyleField as S, type GroupInset as T, HOPS_DOC_KEY as U, type HopsDocValue as V, type LayoutAxes as W, type OutlineDef as X, type PortSite as Y, type RowBox as Z, type RowPort as _, type Row as a, type Slot as a0, anchorOffset as a1, axesFor as a2, bodyBox as a3, bodyOutline as a4, bodyTrait as a5, boxForContent as a6, buildGraph as a7, canvasMeasure as a8, contentBox as a9, untilSettled as aA, extent as aB, createDiagramNodes as aa, dataKeyReader as ab, diagramContainerOf as ac, diagramNodeOf as ad, expandGroupEdges as ae, graphOrder as af, headerBox as ag, insetOf as ah, isPinned as ai, layoutBody as aj, layoutRowPorts as ak, measureBody as al, outlineDetail as am, outlinePath as an, packAcross as ao, packClusters as ap, pinnedSet as aq, planOf as ar, plannerPlan as as, rankGaps as at, registerOutline as au, seededOrder as av, settle as aw, sizeToBody as ax, titleIdOf as ay, translated as az, type PortSpec as b, type LayoutFn as c, type LayoutOptions as d, type DiagramNode as e, type Port as f, type DiagramNodeLike as g, type DiagramNodeReader as h, type DiagramContainer as i, type ContainerHeader as j, type Bounds as k, type LayoutResult as l, type GraphSource as m, type LayoutPlanner as n, type LayoutDirection as o, type LayoutPlan as p, type GraphNodeLike as q, type BodyDivider as r, type BodyFloor as s, type BodyLayout as t, type BuildGraphOptions as u, type BuiltinOutline as v, DEFAULT_GROUP_INSET as w, DEFAULT_HOP_SIZE as x, DEFAULT_NODE_GAP as y, DEFAULT_RANK_GAP as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/diagram",
-  "version": "1.13.0",
+  "version": "1.14.1",
   "description": "Node-link diagramming for weasel: any scene node becomes a diagram participant, with ports on its perimeter and an optional body builder for flowchart-shaped boxes.",
   "license": "MIT",
   "type": "module",
@@ -33,13 +33,13 @@
   },
   "peerDependencies": {
     "react": ">=18",
-    "@weasel-js/animator": "1.13.0",
-    "@weasel-js/audio": "1.13.0",
-    "@weasel-js/core": "1.13.0",
-    "@weasel-js/font": "1.13.0",
-    "@weasel-js/geom": "1.13.0",
-    "@weasel-js/react": "1.13.0",
-    "@weasel-js/simulation": "1.13.0"
+    "@weasel-js/animator": "1.14.1",
+    "@weasel-js/audio": "1.14.1",
+    "@weasel-js/core": "1.14.1",
+    "@weasel-js/font": "1.14.1",
+    "@weasel-js/geom": "1.14.1",
+    "@weasel-js/react": "1.14.1",
+    "@weasel-js/simulation": "1.14.1"
   },
   "peerDependenciesMeta": {
     "@weasel-js/audio": {
@@ -50,7 +50,9 @@
     "table": "./dist/icons.table.json"
   },
   "dependencies": {
-    "@weasel-js/icons": "1.13.0"
+    "@weasel-js/clock": "1.14.1",
+    "@weasel-js/headless": "1.14.1",
+    "@weasel-js/icons": "1.14.1"
   },
   "author": "orochi235",
   "homepage": "https://orochi235.github.io/weasel/",