@weasel-js/diagram 1.11.0 → 1.12.0

package/dist/{body-2lC7IiIA.d.ts → types-M_ccNAlk.d.ts}

@@ -1,12 +1,12 @@
-import * as _weasel_js_geom from '@weasel-js/geom';
 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 —
- * plus `'rect'` for everything else and
+ * 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
@@ -26,7 +26,7 @@ interface Bounds {
 /** 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' | 'parallelogram' | 'trapezoid' | 'hexagon' | Path;
+type Outline = 'rect' | 'diamond' | 'stadium' | 'ellipse' | 'parallelogram' | 'trapezoid' | 'hexagon' | 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;
@@ -58,94 +58,45 @@ declare function boxForContent(outline: Outline, content: {
 };
 
 /**
- * Where a port sits on its node, in **normalized bounds coordinates**:
- * `(0, 0)` is the top-left corner of the node's AABB and `(1, 1)` the
- * bottom-right. `COMPASS` names the eight positions almost everything wants.
- *
- * Normalized rather than absolute because a node's size is authored data that
- * resize, align and distribute all write — a port fixed at an offset would
- * drift off the shape the first time one of them ran.
+ * 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.
  */
-interface PortAnchor {
-    u: number;
-    v: number;
-}
-/** One more place a port may sit, and optionally the direction it faces there. */
-interface PortSite extends PortAnchor {
-    normal?: Vec2 | null;
-}
-/** One attachment point declared on a node. */
-interface PortSpec {
-    /** Unique within the node. Edges name this, so it outlives a re-layout. */
-    id: string;
-    at: PortAnchor;
-    /** Other places the port may sit. An edge meeting the port takes whichever
-     *  of `at` and these faces the edge's next point most directly, so a
-     *  diamond's second exit can leave by its top or its bottom vertex, toward
-     *  wherever its wire goes. Everything else that shows a port where it is —
-     *  the connect affordance, `portsOf` — reads `at`. A site faces away from
-     *  the node's center unless it gives a `normal` of its own. */
-    sites?: readonly PortSite[];
-    /** Consulted by a connect gesture's validity predicate. Uninterpreted here. */
-    type?: string;
-    /** What the port is for, drawn beside it outside the node: beside the
-     *  wire rather than across it. A built body draws it and keeps it in its
-     *  `margin`; any other participant gets it on its resolved `Port`. */
-    label?: string;
-    /** The direction an edge leaves along, overriding the one the anchor
-     *  implies. `null` means "no preferred direction" — a router goes straight
-     *  at it. Applies at `at`; each of `sites` says its own. */
-    normal?: Vec2 | null;
-}
-/**
- * The trait that makes an existing scene node a diagram participant.
- *
- * Attached to a node's `data`, not a node kind the plugin mints: a text block,
- * an image, a path, a group or a plain rect all take part by carrying this,
- * and nothing has to be authored through this package to be connectable.
- */
-interface DiagramNode {
-    /** Defaults to {@link DEFAULT_PORTS} — the four edge midpoints of the
-     *  node's own bounds, which every node has. */
-    ports?: readonly PortSpec[];
-    /** Layout must not move this node. */
-    pinned?: boolean;
-    /** What the node is *drawn* as. Present on a built body; absent on a
-     *  participant that already had a look of its own — a text block, an image,
-     *  a path — which keeps whatever painter it already matched. */
-    outline?: Outline;
-    /** Present on a group's box: a node drawn around the participants it
-     *  depends on, which layout keeps together and leaves room for. The box
-     *  itself is never laid out — it derives its pose from its members — but an
-     *  edge can attach to it like any participant. */
-    group?: DiagramGroup;
-    /** How far past its bounds something drawn with it reaches, on each side —
-     *  a built body's port labels. Layout keeps neighbors that far off too. */
-    margin?: GroupInset;
-}
-/** The group half of a {@link DiagramNode}. */
-interface DiagramGroup {
-    /** Room the box keeps around its members, in world units: one number for
-     *  every side, or per side. Default 12 on each. */
-    inset?: number | Partial<GroupInset>;
-    /** The narrowest the box may be, in world units, as room for its label.
-     *  A box its members leave narrower grows evenly on both sides. */
-    minWidth?: number;
-}
-/** A port resolved against a node's current pose: where it is in world
- *  coordinates, and which way an edge leaves it. */
-interface Port {
-    id: string;
-    /** The node this port belongs to. */
-    nodeId: string;
-    /** World point an edge attaches to. */
-    point: Vec2;
-    /** Unit vector pointing away from the node, or `null` when the port
-     *  declared no direction. Rotated with the node. */
-    normal: Vec2 | null;
-    type?: string;
-    label?: string;
-}
+
+/** 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;
 
 /**
  * Reading the `DiagramNode` trait off a scene node.
@@ -190,7 +141,7 @@ interface DiagramNodeEntry {
  *  the two apart. Without that test an edge reads as a participant declaring
  *  no ports, and collects the four defaults on the degenerate pose an edge
  *  carries. An edge label's `label` trait and an anchored node's `anchor` are
- *  excluded the same way. */
+ *  excluded the same way, and so is a pool's lane, which takes no connectors. */
 declare const dataKeyReader: DiagramNodeReader;
 /**
  * A reader over declared kinds. A trait on the node's own data still wins, so
@@ -257,6 +208,9 @@ interface GraphGroup {
     minWidth?: number;
     /** The group this one is directly inside. */
     parent?: string;
+    /** Its direct members, nodes and groups, in the order a layered layout
+     *  keeps them across every rank: set for a group that reorders. */
+    ordered?: readonly string[];
 }
 /** One connection. `id` is the edge node's own id, so a caller can go back to
  *  the scene for its trait. */
@@ -520,7 +474,7 @@ declare const DEFAULT_GROUP_INSET = 12;
  * across it. A group's inset there includes that of any group nested in it
  * that ends, or starts, at the same rank. `rows` is the nodes of each rank.
  */
-declare function rankGaps(graph: Graph, rows: readonly (readonly GraphNode[])[], axes: LayoutAxes, rankGap: number): number[];
+declare function rankGaps(graph: Pick<Graph, 'groups'>, rows: readonly (readonly Pick<GraphNode, 'id'>[])[], axes: LayoutAxes, rankGap: number): number[];
 /**
  * Cross positions for every node, with each group's members kept in a column
  * of their own, and a nested group in a column inside its parent's.
@@ -540,53 +494,165 @@ declare function packClusters(graph: Graph, rows: readonly (readonly GraphNode[]
 declare function expandGroupEdges(edges: readonly GraphEdge[], groups: readonly GraphGroup[]): GraphEdge[];
 
 /**
- * Perimeter port labels: where the text naming a port is drawn, and how far
- * past its node that reaches.
+ * The container trait: what makes a core `ContainerNode` a diagram container,
+ * a pool, or one of a pool's lanes, and where its header is.
  *
- * A label sits outside the node, on the port's own face, and to one side of
- * the line the port's wire leaves along, so the wire does not run through it.
- * A port inside a row draws its label inside the box instead; that is a
- * `ports` row's job, not this module's.
+ * A container's title is a text child in its header, named
+ * `<container id>/title`. The layouts find it by that name, because a layout
+ * strategy sees only ids and poses.
  */
 
-/** Between a port and the near sides of its label, in world units. */
-declare const PORT_LABEL_GAP = 4;
+/** Which kind of region a container is. */
+type ContainerRole = 'container' | 'pool' | 'lane';
+/** The strip a container's title sits in, along one side. */
+interface ContainerHeader {
+    side: 'top' | 'left';
+    /** Its depth into the container, in world units. */
+    size: number;
+}
+/** The container half of a diagram node's trait, under `data.diagram.container`. */
+interface DiagramContainer {
+    role: ContainerRole;
+    header?: ContainerHeader;
+    /** 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;
+}
+type Box = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/** The container trait on a node's data, or `null`. */
+declare function diagramContainerOf(node: {
+    data: unknown;
+}): DiagramContainer | null;
+/** The id of a container's title node. */
+declare const titleIdOf: (containerId: string) => string;
+/** The header strip of a container at `bounds`; null with no header. */
+declare function headerBox(bounds: Box, header: ContainerHeader | undefined): Box | null;
+/** What a container at `bounds` holds members in: everything past its header. */
+declare function bodyBox(bounds: Box, header: ContainerHeader | undefined): Box;
+
+/** A color on a shape or connector that the author can set by hand, and a theme then leaves alone.
+ *  On a connector, `text` is its label's color. */
+type StyleField = 'fill' | 'stroke' | 'text';
+/** A part of a shape's or connector's text face the author can set by hand, which a theme then
+ *  leaves alone. Kept apart from {@link StyleField}, so choosing a role, which hands back the
+ *  colors, keeps it. */
+type FontField = 'size';
+
 /**
- * Where a label `size` big goes for a port at `point` facing `normal`.
+ * Where a port sits on its node, in **normalized bounds coordinates**:
+ * `(0, 0)` is the top-left corner of the node's AABB and `(1, 1)` the
+ * bottom-right. `COMPASS` names the eight positions almost everything wants.
  *
- * A port on a left or right face gets its label outside that face, above its
- * wire; one on a top or bottom face, outside that face, right of its wire; a
- * corner port, off the corner. A port with no direction gets it centered
- * above.
+ * Normalized rather than absolute because a node's size is authored data that
+ * resize, align and distribute all write — a port fixed at an offset would
+ * drift off the shape the first time one of them ran.
  */
-declare function portLabelBox(port: {
+interface PortAnchor {
+    u: number;
+    v: number;
+}
+/** One more place a port may sit, and optionally the direction it faces there. */
+interface PortSite extends PortAnchor {
+    normal?: Vec2 | null;
+}
+/** One attachment point declared on a node. */
+interface PortSpec {
+    /** Unique within the node. Edges name this, so it outlives a re-layout. */
+    id: string;
+    at: PortAnchor;
+    /** Other places the port may sit. An edge meeting the port takes whichever
+     *  of `at` and these faces the edge's next point most directly, so a
+     *  diamond's second exit can leave by its top or its bottom vertex, toward
+     *  wherever its wire goes. Everything else that shows a port where it is —
+     *  the connect affordance, `portsOf` — reads `at`. A site faces away from
+     *  the node's center unless it gives a `normal` of its own. */
+    sites?: readonly PortSite[];
+    /** Consulted by a connect gesture's validity predicate. Uninterpreted here. */
+    type?: string;
+    /** What the port is for, drawn beside it outside the node: beside the
+     *  wire rather than across it. A built body draws it and keeps it in its
+     *  `margin`; any other participant gets it on its resolved `Port`. */
+    label?: string;
+    /** The direction an edge leaves along, overriding the one the anchor
+     *  implies. `null` means "no preferred direction" — a router goes straight
+     *  at it. Applies at `at`; each of `sites` says its own. */
+    normal?: Vec2 | null;
+}
+/**
+ * The trait that makes an existing scene node a diagram participant.
+ *
+ * Attached to a node's `data`, not a node kind the plugin mints: a text block,
+ * an image, a path, a group or a plain rect all take part by carrying this,
+ * and nothing has to be authored through this package to be connectable.
+ */
+interface DiagramNode {
+    /** Defaults to {@link DEFAULT_PORTS} — the four edge midpoints of the
+     *  node's own bounds, which every node has. */
+    ports?: readonly PortSpec[];
+    /** Layout must not move this node. */
+    pinned?: boolean;
+    /** What the node is *drawn* as. Present on a built body; absent on a
+     *  participant that already had a look of its own — a text block, an image,
+     *  a path — which keeps whatever painter it already matched. */
+    outline?: Outline;
+    /** Present on a group's box: a node drawn around the participants it
+     *  depends on, which layout keeps together and leaves room for. The box
+     *  itself is never laid out — it derives its pose from its members — but an
+     *  edge can attach to it like any participant. */
+    group?: DiagramGroup;
+    /** Present on a container, a pool, or a lane: a `ContainerNode` holding
+     *  members (`containers/trait.ts`). */
+    container?: DiagramContainer;
+    /** How far past its bounds something drawn with it reaches, on each side —
+     *  a built body's port labels. Layout keeps neighbors that far off too. */
+    margin?: GroupInset;
+    /** The theme role it is drawn in. Unset, the theme's default role. */
+    style?: string;
+    /** The colors the author set by hand, which a theme leaves as they are. */
+    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`. */
+    body?: BodyLayout;
+}
+/** How a built body stacks its text rows: the `BodySpec` fields its layout reads, and how many rows. */
+interface BodyLayout {
+    padding: number;
+    gap: number;
+    verticalAlign: 'top' | 'center' | 'bottom';
+    rows: number;
+}
+/** The group half of a {@link DiagramNode}. */
+interface DiagramGroup {
+    /** Room the box keeps around its members, in world units: one number for
+     *  every side, or per side. Default 12 on each. */
+    inset?: number | Partial<GroupInset>;
+    /** The narrowest the box may be, in world units, as room for its label.
+     *  A box its members leave narrower grows evenly on both sides. */
+    minWidth?: number;
+    /** The axis its members can be dragged along to change their order. */
+    reorder?: 'x' | 'y';
+}
+/** A port resolved against a node's current pose: where it is in world
+ *  coordinates, and which way an edge leaves it. */
+interface Port {
+    id: string;
+    /** The node this port belongs to. */
+    nodeId: string;
+    /** World point an edge attaches to. */
     point: Vec2;
+    /** Unit vector pointing away from the node, or `null` when the port
+     *  declared no direction. Rotated with the node. */
     normal: Vec2 | null;
-}, size: {
-    width: number;
-    height: number;
-}, gap?: number): Bounds;
-/** Where a built body's perimeter port label sits, as `buildBody`'s
- *  `portLabel` is handed it. */
-interface PerimeterPortLabelBox extends Bounds {
-    port: PortSpec;
-    side: 'outside';
-}
-/** A labeled port, resolved, and the box its label is drawn in. */
-interface PortLabelPlacement {
-    port: Port & {
-        label: string;
-    };
-    box: Bounds;
+    type?: string;
+    label?: string;
 }
-/** Every labeled port of `trait` resolved against `bounds`, with its label's
- *  box. `size` measures one label. */
-declare function portLabelsOf(trait: DiagramNode, bounds: Bounds, size: (text: string) => {
-    width: number;
-    height: number;
-}): PortLabelPlacement[];
-/** How far `boxes` reach past `bounds` on each side; `undefined` for none. */
-declare function marginOf(bounds: Bounds, boxes: readonly Bounds[]): GroupInset | undefined;
 
 /** One line of body content. */
 type Row = 
@@ -659,20 +725,6 @@ interface BodySpec {
     /** Perimeter port labels by id, drawn outside the box; over a port's own `label`. */
     portLabels?: Readonly<Record<string, string>>;
 }
-/** What {@link buildBody} emits: the `AddNodeSpec` fields it fills in. Named
- *  structurally rather than imported so a consumer whose scene is typed
- *  differently can still spread one. */
-interface BodyNodeSpec<TData, TLayer extends string, TPose> {
-    kind: 'container' | 'leaf';
-    layer: TLayer;
-    pose: TPose;
-    data: TData;
-    id?: string;
-    parent?: string;
-    /** Set `false` on every leaf the builder emits: the innermost hit wins, so a
-     *  row that answers a press is a body that cannot be dragged. */
-    pickable?: boolean;
-}
 /** The floor a body's content puts under its node's size. */
 interface BodyFloor {
     minWidth: number;
@@ -744,43 +796,30 @@ declare function bodyTrait(spec: BodySpec, bounds: Bounds, measure?: MeasureRowT
 /** The outline path for a built body at `bounds` — what paints it, and what a
  *  perimeter-hugging port will eventually be placed on. */
 declare function bodyOutline(spec: BodySpec, bounds: Bounds): _weasel_js_geom.Path;
-/** What a built body's rows are handed to, one call per row.
- *
- *  `text` is the row's content already formatted — a `label`'s own text, or a
- *  `field`'s `"label: value"` — so the common case needs no discrimination.
- *  Return `null` for a row the consumer paints itself; `ports` and `slot` rows
- *  arrive with `text` empty and are the usual ones to decline. */
-type RowNodeData<TData> = (text: string, box: RowBox) => TData | null;
-/** Options for {@link buildBody}: the layer and data of each node it emits.
- *  Without `measure`, rows are sized from a fallback line height rather than
- *  their text. */
-interface BuildBodyOptions<TData, TLayer extends string, TPose extends Bounds> {
-    layer: TLayer;
-    /** The container's id. Edges name it, so pass one for anything an edge or a
-     *  layout `pin` will refer to. */
-    id?: string;
-    measure?: MeasureRowText;
-    /** The container's own data, given the trait the builder computed and the
-     *  pose it was computed against. */
-    body: (trait: DiagramNode, pose: TPose) => TData;
-    /** One row's data, or `null` to leave that row undrawn. */
-    row: RowNodeData<TData>;
-    /** One port's label — a row port's or a perimeter port's — or `null` to
-     *  leave it undrawn. Ports with no label are never offered. Omit to draw none. */
-    portLabel?: (text: string, box: RowPortBox | PerimeterPortLabelBox) => TData | null;
-}
+
 /**
- * The scene nodes a built body is: one container carrying the trait, and one
- * leaf per row that wants drawing.
- *
- * Rows are ordinary scene nodes rather than something this package paints, so
- * the kit's own text painter draws them and text editing, styling, and
- * selection work on them unchanged. The returned pose is `at` grown to fit the
- * body, never shrunk.
+ * Line jumps as data: the document value that turns them on, and the hops a
+ * connector carries. Plain data, so layout and any reader can use it.
  */
-declare function buildBody<TData, TLayer extends string, TPose extends Bounds>(spec: BodySpec, at: TPose, opts: BuildBodyOptions<TData, TLayer, TPose>): {
-    pose: TPose;
-    specs: BodyNodeSpec<TData, TLayer, TPose>[];
-};
 
-export { buildGraph as $, type GraphNode as A, type BodySpec as B, type GroupInset as C, type DiagramGroup as D, type EdgeLabelRoom as E, type LayoutAxes as F, type Graph as G, PORT_LABEL_GAP as H, type PerimeterPortLabelBox as I, type PortLabelPlacement as J, type PortSite as K, type LayoutPorts as L, type MeasureRowText as M, type RowBox as N, type Outline as O, type PortAnchor as P, type RowNodeData as Q, type RowTextStyle as R, type RowPort as S, type RowPortBox as T, type Slot as U, anchorOffset as V, axesFor as W, bodyOutline as X, bodyTrait as Y, boxForContent as Z, buildBody as _, type Row as a, canvasMeasure as a0, contentBox as a1, createDiagramNodes as a2, dataKeyReader as a3, diagramNodeOf as a4, expandGroupEdges as a5, graphOrder as a6, insetOf as a7, isPinned as a8, layoutBody as a9, layoutRowPorts as aa, marginOf as ab, measureBody as ac, outlinePath as ad, packAcross as ae, packClusters as af, pinnedSet as ag, planOf as ah, plannerPlan as ai, portLabelBox as aj, portLabelsOf as ak, rankGaps as al, seededOrder as am, settle as an, sizeToBody as ao, translated as ap, untilSettled as aq, extent as ar, 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 LayoutResult as i, type GraphSource as j, type LayoutPlanner as k, type LayoutDirection as l, type LayoutPlan as m, type GraphNodeLike as n, type BodyFloor as o, type BodyNodeSpec as p, type Bounds as q, type BuildBodyOptions as r, type BuildGraphOptions as s, DEFAULT_GROUP_INSET as t, DEFAULT_NODE_GAP as u, DEFAULT_RANK_GAP as v, DIAGRAM_TRAIT_KEY as w, type DiagramNodeEntry as x, type GraphEdge as y, type GraphGroup as z };
+/** The document value (`scene.doc`) holding the line-jump setting: present
+ *  while hops are on, absent while off. */
+declare const HOPS_DOC_KEY = "diagram:hops";
+/** The line-jump setting while it is on. */
+interface HopsDocValue {
+    /** A hop's radius, in world units. */
+    size: number;
+}
+/** The radius a hop takes when nothing sets one. */
+declare const DEFAULT_HOP_SIZE = 5;
+/** Where a connector bows over others: a half circle of radius `r` centered
+ *  on `at`, which lies on the connector's route. `over` names the connectors
+ *  it passes over; hops closer than `2r` merge into one, which passes over all
+ *  of theirs. */
+interface EdgeHop {
+    at: Vec2;
+    over: readonly string[];
+    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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/diagram",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "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",
@@ -21,15 +21,36 @@
       "import": "./dist/effect.js",
       "types": "./dist/effect.d.ts"
     },
+    "./effect-audio": {
+      "import": "./dist/effect-audio.js",
+      "types": "./dist/effect-audio.d.ts"
+    },
+    "./icons": {
+      "import": "./dist/icons.table.js",
+      "types": "./dist/icons.table.d.ts"
+    },
     "./package.json": "./package.json"
   },
   "peerDependencies": {
     "react": ">=18",
-    "@weasel-js/animator": "1.11.0",
-    "@weasel-js/core": "1.11.0",
-    "@weasel-js/font": "1.11.0",
-    "@weasel-js/geom": "1.11.0",
-    "@weasel-js/simulation": "1.11.0"
+    "@weasel-js/animator": "1.12.0",
+    "@weasel-js/audio": "1.12.0",
+    "@weasel-js/core": "1.12.0",
+    "@weasel-js/font": "1.12.0",
+    "@weasel-js/geom": "1.12.0",
+    "@weasel-js/react": "1.12.0",
+    "@weasel-js/simulation": "1.12.0"
+  },
+  "peerDependenciesMeta": {
+    "@weasel-js/audio": {
+      "optional": true
+    }
+  },
+  "weaselIcons": {
+    "table": "./dist/icons.table.json"
+  },
+  "dependencies": {
+    "@weasel-js/icons": "1.12.0"
   },
   "author": "orochi235",
   "homepage": "https://orochi235.github.io/weasel/",
@@ -50,7 +71,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsup"
+    "build": "tsup && cp src/icons.table.json dist/"
   },
   "publishConfig": {
     "access": "public",