@weasel-js/diagram 1.9.3 → 1.10.0

package/dist/layout.d.ts

@@ -1,3 +1,4 @@
-export { j as BodyFloor, k as BodyNodeSpec, B as BodySpec, l as Bounds, m as BuildBodyOptions, C as COMPASS, p as DEFAULT_NODE_GAP, q as DEFAULT_PORTS, r as DEFAULT_RANK_GAP, f as DiagramNode, u as ForceBody, F as ForceOptions, v as ForceRelaxation, i as Graph, w as GraphEdge, y as GraphNode, E as LayoutAxes, H as LayoutDirection, L as LayoutFn, g as LayoutOptions, h as LayoutResult, M as MeasureRowText, O as Outline, P as Port, c as PortAnchor, e as PortSpec, a as PortsOptions, R as Row, I as RowBox, J as RowNodeData, K as RowPort, N as RowPortBox, Q as RowTextStyle, S as Slot, T as axesFor, U as backEdges, V as bodyOutline, X as boxForContent, Y as buildBody, _ as canvasMeasure, $ as contentBox, au as extent, a4 as force, a5 as forceRelaxation, a6 as forestOf, a7 as graphOrder, aa as layered, ab as layoutBody, ac as layoutRowPorts, ad as measureBody, ae as outlinePath, af as outlinePolyline, ag as packAcross, ai as pinnedSet, aj as portOf, ak as portsOf, al as portsOnOutline, an as ranksOf, ao as rayHit, ap as seededOrder, aq as settle, ar as sizeToBody, as as translated, at as tree } from './layout.entry-KHbx5uGC.js';
+export { j as BodyFloor, k as BodyNodeSpec, B as BodySpec, l as Bounds, m as BuildBodyOptions, C as COMPASS, p as DEFAULT_NODE_GAP, q as DEFAULT_PORTS, r as DEFAULT_RANK_GAP, f as DiagramNode, u as ForceBody, F as ForceOptions, v as ForceRelaxation, i as Graph, x as GraphEdge, z as GraphNode, H as LayoutAxes, I as LayoutDirection, L as LayoutFn, g as LayoutOptions, h as LayoutResult, M as MeasureRowText, O as Outline, P as Port, c as PortAnchor, e as PortSpec, a as PortsOptions, R as Row, J as RowBox, K as RowNodeData, N as RowPort, Q as RowPortBox, S as RowTextStyle, T as Slot, U as axesFor, V as backEdges, W as bodyOutline, Y as boxForContent, Z as buildBody, $ as canvasMeasure, a0 as contentBox, aw as extent, a5 as force, a6 as forceRelaxation, a7 as forestOf, a8 as graphOrder, ab as layered, ac as layoutBody, ad as layoutRowPorts, ae as measureBody, af as outlinePath, ag as outlinePolyline, ah as packAcross, aj as pinnedSet, ak as portOf, al as portsOf, am as portsOnOutline, ao as ranksOf, ap as rayHit, aq as seededOrder, ar as settle, as as sizeToBody, at as translated, au as tree, av as untilSettled } from './layout.entry-CIdRpG2i.js';
 import '@weasel-js/geom';
 import '@weasel-js/core/math';
+import '@weasel-js/simulation';

package/dist/{layout.entry-KHbx5uGC.d.ts → layout.entry-CIdRpG2i.d.ts}

@@ -1,5 +1,6 @@
 import * as _weasel_js_geom from '@weasel-js/geom';
-import { Path, PoseDescriptor, Vec2, SimulationNode, createSimulation } from '@weasel-js/core/math';
+import { Path, PoseDescriptor, Vec2 } from '@weasel-js/core/math';
+import { SimulationNode, createSimulation } from '@weasel-js/simulation';
 
 /**
  * The shapes a built body can wear, as paths in the node's bounds.
@@ -56,18 +57,15 @@ declare function boxForContent(outline: Outline, content: {
 /**
  * Reading the `DiagramNode` trait off a scene node.
  *
- * Two ways to attach it, both of which this module's default reader answers:
+ * Two ways to attach it:
  *
- *   - **On the node.** `data.diagram` holds the trait. One node, one answer;
- *     what a connect gesture writes when the author drags a new edge.
+ *   - **On the node.** `data.diagram` holds the trait.
  *   - **By kind.** A consumer declares once which data shapes take part, and
- *     every matching node gets the trait without being stamped. This mirrors
- *     `createNodeRouting` in the kit — a predicate over `data`, first match
- *     wins — and is the shape to reach for when the participants are a class
- *     of node rather than a hand-picked set.
+ *     every matching node gets the trait without being stamped — a predicate
+ *     over `data`, first match wins.
  *
  * A reader is a plain function, so a consumer whose data lives somewhere else
- * entirely passes their own and never touches either form.
+ * passes their own.
  */
 
 /** The key on a node's `data` the default reader looks under. */
@@ -98,17 +96,13 @@ interface DiagramNodeEntry {
  *  An edge's trait lives under the same key, so `from` and `to` are what tells
  *  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 — four grabbable ports in the middle of nowhere. An edge label's
- *  `label` trait and an anchored node's `anchor` are the same story, and would
- *  also take a slot in every layout. */
+ *  carries. An edge label's `label` trait and an anchored node's `anchor` are
+ *  excluded the same way. */
 declare const dataKeyReader: DiagramNodeReader;
 /**
  * A reader over declared kinds. A trait on the node's own data still wins, so
- * a single node can opt out of, or override, whatever its kind says.
- *
- * Throws on a duplicate `name`, for the reason `mergeContributions` does: a
- * class of node silently losing its ports is what this registry exists to make
- * loud.
+ * a single node can opt out of, or override, whatever its kind says. Throws on
+ * a duplicate `name`.
  */
 declare function createDiagramNodes(entries: readonly DiagramNodeEntry[]): DiagramNodeReader;
 /** The trait `node` carries, through `read` (default: its own `data.diagram`). */
@@ -119,15 +113,10 @@ declare function isPinned(node: DiagramNodeLike, read?: DiagramNodeReader): bool
 /**
  * `Graph` — the adjacency index a layout runs over.
  *
- * The scene is the document, so there is no second graph kept in sync with it:
- * this one is built from the scene on demand, used, and thrown away. Rebuilding
- * per layout invocation is deliberate — a maintained index is a cache to
- * invalidate on every add, delete, reparent and `dependsOn` edit, and layout is
- * not on the hot path. Measure before changing that.
- *
- * A node's *identity* is its id and its *size* is its bounds; where it currently
- * sits is here too, because a re-layout that ignores where things already are
- * scrambles a diagram the author has arranged.
+ * Built from the scene on demand, used, and thrown away. Rebuilding per layout
+ * invocation is deliberate — a maintained index is a cache to invalidate on
+ * every add, delete, reparent, and `dependsOn` edit, and layout is not on the
+ * hot path.
  */
 
 /** A scene node as the graph reads it. `dependsOn` is what an edge's two
@@ -149,17 +138,20 @@ interface GraphNode {
     bounds: Bounds;
     /** Layout must not move it. */
     pinned: boolean;
-    /** The group it belongs to, when it belongs to one. */
+    /** The innermost group it belongs to, when it belongs to one. */
     group?: string;
 }
 /** A box drawn around some participants, which a layout keeps together and
  *  leaves room for. */
 interface GraphGroup {
     id: string;
-    /** In source order. */
+    /** Every participant inside, through any group nested in this one, in
+     *  source order. */
     members: readonly string[];
-    /** Room the box keeps around its members, in world units. */
+    /** Room the box keeps around what it holds, in world units. */
     inset: GroupInset;
+    /** The group this one is directly inside. */
+    parent?: string;
 }
 /** One connection. `id` is the edge node's own id, so a caller can go back to
  *  the scene for its trait. */
@@ -172,8 +164,7 @@ interface GraphEdge {
  * Nodes, edges, and the two adjacency reads a layout needs.
  *
  * Every list is in source order — render order, when the source is a scene —
- * which is what a layout's tiebreaks resolve against. There is no RNG anywhere
- * downstream of this, and this is where that starts.
+ * which is what a layout's tiebreaks resolve against.
  */
 interface Graph {
     readonly nodes: readonly GraphNode[];
@@ -197,11 +188,10 @@ interface BuildGraphOptions<TPose> {
  *
  * A node is an edge if it carries the edge trait and names exactly two
  * dependencies; a group if its trait carries `group`, with its dependencies as
- * its members; a participant if the reader hands back any other
+ * its members, which may be groups themselves (see `nestGroups`); a participant if the reader hands back any other
  * `DiagramNode`; and otherwise not in the diagram at all. An edge whose
- * endpoints are not both participants or groups is dropped — a dangling edge
- * should not be ranking anything — and an edge to a group ranks against its
- * members (see `expandGroupEdges`).
+ * endpoints are not both participants or groups is dropped, and an edge to a
+ * group ranks against its members (see `expandGroupEdges`).
  */
 declare function buildGraph<TPose>(source: GraphSource<TPose>, opts?: BuildGraphOptions<TPose>): Graph;
 
@@ -210,24 +200,19 @@ declare function buildGraph<TPose>(source: GraphSource<TPose>, opts?: BuildGraph
  *
  * A layout is a pure function of the graph — no scene, no ops, no history. It
  * hands back the new top-left for every node that **moves**, and a node already
- * standing where the layout wants it is simply absent from the answer. That is
- * what makes re-running a layout free rather than destructive, and it is the
- * property the idempotence test asserts.
+ * standing where the layout wants it is absent from the answer.
  *
- * Three rules keep re-layout non-destructive, and all three live here rather
- * than in each algorithm:
+ * Three rules keep re-layout non-destructive:
  *
  *   - **No RNG anywhere.** Every tiebreak falls back to the graph's own node
- *     order, which is the source's order — render order, for a scene.
+ *     order.
  *   - **Within-rank order is seeded from where the nodes already are**, read
- *     off the cross axis, rather than from crossing-minimization. An author who
- *     dragged two boxes into an order gets that order back.
+ *     off the cross axis, rather than from crossing-minimization.
  *   - **A pin set nothing moves.** Pinned nodes are never in the result, and
  *     the rest of the layout is translated to sit around them.
  *
- * `layered` and `tree` are idempotent by construction: the second run reads the
- * order the first run produced and computes the same slots. `force` is an
- * iterative relaxation and makes no such claim — re-running it keeps relaxing.
+ * `layered` and `tree` are idempotent; `force` is an iterative relaxation and
+ * re-running it keeps relaxing.
  */
 
 /** Which way the ranks stack. `force` ignores it. */
@@ -284,32 +269,32 @@ interface Slot {
     rank: number;
 }
 /**
- * Turn canonical slots into the positions to write.
+ * Turn canonical slots into the positions to write: map the canonical frame
+ * onto the world axes, translate the whole layout so it lands where the graph
+ * already is, and drop everything that is pinned or that would not move.
  *
- * Three steps, in order: map the canonical frame onto the world axes the
- * direction names; translate the whole layout so it lands where the graph
- * already is; drop everything that is pinned or that would not move.
- *
- * The translation is what makes the layout non-destructive, and it is chosen so
- * that a second run lands on the same answer. With a pin, it is whatever keeps
- * the first pinned node exactly where it is. Without one, it is whatever puts
- * the layout's own bounding box where the graph's bounding box already starts —
- * which the first run then makes true, so the second run computes the same
- * translation and writes nothing.
+ * With a pin, the translation keeps the first pinned node exactly where it is.
+ * Without one, it puts the layout's bounding box where the graph's already
+ * starts, so a second run computes the same translation and writes nothing.
  */
 declare function settle(graph: Graph, slots: ReadonlyMap<string, Slot>, opts?: LayoutOptions): LayoutResult;
+/**
+ * Run `once` until a pass moves nothing, and answer with where that leaves
+ * each node.
+ *
+ * A layout that keeps groups together can move an outsider out of a group's
+ * column, which changes the order the next run would start from. `passes`
+ * bounds an arrangement that never comes to rest.
+ */
+declare function untilSettled(once: LayoutFn, graph: Graph, opts?: LayoutOptions, passes?: number): LayoutResult;
 /**
  * {@link settle}'s second half, for a layout that already works in world
- * coordinates — `force` does, since the integrator moves points around rather
- * than filling slots.
+ * coordinates.
  */
 declare function translated(graph: Graph, placed: ReadonlyMap<string, Vec2>, pinned: ReadonlySet<string>, tolerance?: number): LayoutResult;
 /**
  * Lay a list of nodes out along the cross axis, in the order given, and hand
  * back each one's low corner plus the total span.
- *
- * Shared by `layered`'s ranks and `tree`'s sibling rows, which pack a row the
- * same way and differ only in what decides the order.
  */
 declare function packAcross(nodes: readonly GraphNode[], axis: 'x' | 'y', gap: number): {
     at: Map<string, number>;
@@ -331,9 +316,9 @@ declare function graphOrder(graph: Graph): (id: string) => number;
  * to its last — including a rank in between that holds none of its members, or
  * an outsider would land inside the box there. Groups keep one cross position
  * across every rank, so two groups' columns never cross and their boxes never
- * overlap. Ungrouped nodes pack around the columns rank by rank, as before.
+ * overlap. Ungrouped nodes pack around the columns rank by rank.
  *
- * Groups are flat: a group is not a member of another group.
+ * A group may be a member of another: its column then sits inside its parent's.
  */
 
 /** Room a group's box keeps around its members, in world units. */
@@ -351,23 +336,25 @@ declare const DEFAULT_GROUP_INSET = 12;
  * The gap between each rank and the next, widened so a group's box fits: the
  * widest inset of a group ending at rank `i` and of one starting at `i + 1`
  * both come on top of `rankGap`, since those two boxes can face each other
- * across it. `rows` is the nodes of each rank.
+ * 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[];
 /**
  * Cross positions for every node, with each group's members kept in a column
- * of their own. `preferred` is where the layout would put each node's low
- * corner with no groups at all; nodes and columns keep that order and are only
- * ever pushed toward the high end, by as much as it takes to stop overlapping.
+ * of their own, and a nested group in a column inside its parent's.
+ * `preferred` is where the layout would put each node's low corner with no
+ * groups at all; nodes and columns keep that order and are only ever pushed
+ * toward the high end, by as much as it takes to stop overlapping.
  */
 declare function packClusters(graph: Graph, rows: readonly (readonly GraphNode[])[], preferred: ReadonlyMap<string, number>, axes: LayoutAxes, nodeGap: number): Map<string, number>;
 /**
  * Edges as a layout should rank by: one into a group arrives at its entry
  * members — those no other member points at — and one out of it leaves from its
  * exit members. A group with no such member, a pure cycle, is all entries and
- * all exits. An edge between a group and one of its own members, or two
- * members of one group, is a group's internal business and ranks nothing
- * beyond what its member-to-member edges already do.
+ * all exits. An edge between a group and something inside it, a member or a
+ * nested group, is that group's internal business and ranks nothing beyond
+ * what its member-to-member edges already do.
  */
 declare function expandGroupEdges(edges: readonly GraphEdge[], groups: readonly GraphGroup[]): GraphEdge[];
 
@@ -452,9 +439,7 @@ type Row =
     value: string;
     style?: RowTextStyle;
 }
-/** A row that carries ports on its own left and right edges — the
- *  visual-programming shape, where an operator's inputs line up with the
- *  rows they feed. */
+/** A row that carries ports on its own left and right edges. */
  | {
     kind: 'ports';
     left?: readonly RowPort[];
@@ -550,8 +535,7 @@ declare function canvasMeasure(ctx: {
 declare function measureBody(spec: BodySpec, measure?: MeasureRowText): BodyFloor;
 /**
  * The authored size, grown to fit the body. Never shrinks: a row removed
- * leaves the node the size the author last saw it at, which is the only
- * behavior that survives a resize the author did on purpose.
+ * leaves the node the size the author last saw it at.
  */
 declare function sizeToBody<TPose extends Bounds>(pose: TPose, floor: BodyFloor): TPose;
 /** Where each row sits inside `bounds`, top to bottom. Rows keep their
@@ -559,8 +543,7 @@ declare function sizeToBody<TPose extends Bounds>(pose: TPose, floor: BodyFloor)
  *  places the block of them within it. */
 declare function layoutBody(spec: BodySpec, bounds: Bounds, measure?: MeasureRowText): RowBox[];
 /**
- * Where each of a `ports` row's ports goes inside `box`, on the same terms
- * `layoutBody` gives one box per row.
+ * Where each of a `ports` row's ports goes inside `box`.
  *
  * Both sides are cut into the same number of slots — the longer side's count —
  * so the nth input faces the nth output whichever side has more. A label box
@@ -576,13 +559,12 @@ declare function layoutRowPorts(row: Extract<Row, {
  * left or right edge.
  *
  * Anchors are normalized against `bounds`, so they survive the node being
- * resized — which is the whole reason `PortAnchor` is normalized.
+ * resized.
  *
  * **A row port on a side takes that side's compass default with it.** Both sit
  * on the same edge, and a row near the vertical middle puts one exactly on top
  * of `w` or `e` — where the later region wins the hit and the other is
- * grabbable nowhere. A body that declares where its inputs attach has said what
- * that side is for.
+ * grabbable nowhere.
  */
 declare function bodyTrait(spec: BodySpec, bounds: Bounds, measure?: MeasureRowText): DiagramNode;
 /** The outline path for a built body at `bounds` — what paints it, and what a
@@ -610,8 +592,7 @@ interface BuildBodyOptions<TData, TLayer extends string, TPose extends Bounds> {
     /** One row's data, or `null` to leave that row undrawn. */
     row: RowNodeData<TData>;
     /** One row port's label, or `null` to leave it undrawn. Ports with no
-     *  `label` are never offered. Omit to draw none — a body whose ports are
-     *  named only for the width they claim needs nothing here. */
+     *  `label` are never offered. Omit to draw none. */
     portLabel?: (text: string, box: RowPortBox) => TData | null;
 }
 /**
@@ -619,13 +600,9 @@ interface BuildBodyOptions<TData, TLayer extends string, TPose extends Bounds> {
  * 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 walk that places them is
- * `layoutBody` — the same one `bodyTrait` anchors its row ports against, which
- * is why a label and its ports cannot drift apart.
- *
- * The pose is `sizeToBody(at, measureBody(spec))`: the body measures a floor
- * and the authored size is grown to clear it, never shrunk.
+ * 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.
  */
 declare function buildBody<TData, TLayer extends string, TPose extends Bounds>(spec: BodySpec, at: TPose, opts: BuildBodyOptions<TData, TLayer, TPose>): {
     pose: TPose;
@@ -708,15 +685,10 @@ declare function portOf<TPose>(node: DiagramNodeLike, pose: TPose, portId: strin
  * Seeded from where the nodes already are rather than from a fresh random
  * scatter: an author who has arranged half a diagram gets that arrangement
  * relaxed, not replaced. There is no RNG in it at all — two coincident nodes
- * are separated along a golden-angle spiral keyed to their index, which is what
- * a random jiggle is for elsewhere.
+ * are separated along a golden-angle spiral keyed to their index.
  *
- * The integrator is the kit's own `createSimulation`, the same one
- * `useSimulation` runs a frame at a time. Only the forces are local, and they
- * are the naive O(n²) kind — right for the tens-to-hundreds of nodes an
- * edge-per-scene-node diagram is already sized for, wrong for a 10k-node graph,
- * which wants d3-force's Barnes–Hut through `useSimulation` and its own render
- * layer.
+ * The forces are the naive O(n²) kind — right for tens to hundreds of nodes,
+ * wrong for a 10k-node graph.
  *
  * **This is the one layout that is not idempotent.** A relaxation re-run from
  * its own output keeps relaxing; `direction` means nothing to it. Pins and the
@@ -739,6 +711,8 @@ interface ForceOptions extends LayoutOptions {
     gravity?: number;
     /** Clear space kept between two boxes, in world units. Default 24. */
     padding?: number;
+    /** How hard a group draws its members together, 0..1. Default 0.2. */
+    groupStrength?: number;
 }
 /** One node as the relaxation sees it: a simulation point centered on the
  *  node's box. */
@@ -751,10 +725,6 @@ interface ForceBody extends SimulationNode {
 }
 /**
  * The bodies and the force list, wound up and ready to tick.
- *
- * Shared by the one-shot `force` below and the live relaxation in `live.ts`,
- * which ticks it a frame at a time. Two copies of a force list drift, and the
- * only thing that would say so is the arrangement they produce.
  */
 interface ForceRelaxation {
     bodies: ForceBody[];
@@ -786,6 +756,7 @@ declare function ranksOf(graph: Graph, back: ReadonlySet<string>): Map<string, n
  *  moves nothing — except under `order: 'barycenter'`, which reorders them. */
 declare const layered: LayoutFn;
 
+/** A graph read as trees: its roots, each node's children in order, and each node's depth. */
 interface Forest {
     roots: GraphNode[];
     children: Map<string, GraphNode[]>;
@@ -825,4 +796,4 @@ declare function rayHit(poly: readonly number[], center: {
  */
 declare function portsOnOutline(ports: readonly Port[], outline: Outline, bounds: Bounds): Port[];
 
-export { contentBox as $, type GroupInset as A, type BodySpec as B, COMPASS as C, type DiagramNodeLike as D, type LayoutAxes as E, type ForceOptions as F, type GraphSource as G, type LayoutDirection as H, type RowBox as I, type RowNodeData as J, type RowPort as K, type LayoutFn as L, type MeasureRowText as M, type RowPortBox as N, type Outline as O, type Port as P, type RowTextStyle as Q, type Row as R, type Slot as S, axesFor as T, backEdges as U, bodyOutline as V, bodyTrait as W, boxForContent as X, buildBody as Y, buildGraph as Z, canvasMeasure as _, type PortsOptions as a, createDiagramNodes as a0, dataKeyReader as a1, diagramNodeOf as a2, expandGroupEdges as a3, force as a4, forceRelaxation as a5, forestOf as a6, graphOrder as a7, insetOf as a8, isPinned as a9, layered as aa, layoutBody as ab, layoutRowPorts as ac, measureBody as ad, outlinePath as ae, outlinePolyline as af, packAcross as ag, packClusters as ah, pinnedSet as ai, portOf as aj, portsOf as ak, portsOnOutline as al, rankGaps as am, ranksOf as an, rayHit as ao, seededOrder as ap, settle as aq, sizeToBody as ar, translated as as, tree as at, extent as au, type DiagramNodeReader as b, type PortAnchor as c, type DiagramGroup as d, type PortSpec as e, type DiagramNode as f, type LayoutOptions as g, type LayoutResult as h, type Graph as i, type BodyFloor as j, type BodyNodeSpec as k, type Bounds as l, type BuildBodyOptions as m, type BuildGraphOptions as n, DEFAULT_GROUP_INSET as o, DEFAULT_NODE_GAP as p, DEFAULT_PORTS as q, DEFAULT_RANK_GAP as r, DIAGRAM_TRAIT_KEY as s, type DiagramNodeEntry as t, type ForceBody as u, type ForceRelaxation as v, type GraphEdge as w, type GraphGroup as x, type GraphNode as y, type GraphNodeLike as z };
+export { canvasMeasure as $, type GraphNodeLike as A, type BodySpec as B, COMPASS as C, type DiagramNodeLike as D, type GroupInset as E, type ForceOptions as F, type GraphSource as G, type LayoutAxes as H, type LayoutDirection as I, type RowBox as J, type RowNodeData as K, type LayoutFn as L, type MeasureRowText as M, type RowPort as N, type Outline as O, type Port as P, type RowPortBox as Q, type Row as R, type RowTextStyle as S, type Slot as T, axesFor as U, backEdges as V, bodyOutline as W, bodyTrait as X, boxForContent as Y, buildBody as Z, buildGraph as _, type PortsOptions as a, contentBox as a0, createDiagramNodes as a1, dataKeyReader as a2, diagramNodeOf as a3, expandGroupEdges as a4, force as a5, forceRelaxation as a6, forestOf as a7, graphOrder as a8, insetOf as a9, isPinned as aa, layered as ab, layoutBody as ac, layoutRowPorts as ad, measureBody as ae, outlinePath as af, outlinePolyline as ag, packAcross as ah, packClusters as ai, pinnedSet as aj, portOf as ak, portsOf as al, portsOnOutline as am, rankGaps as an, ranksOf as ao, rayHit as ap, seededOrder as aq, settle as ar, sizeToBody as as, translated as at, tree as au, untilSettled as av, extent as aw, type DiagramNodeReader as b, type PortAnchor as c, type DiagramGroup as d, type PortSpec as e, type DiagramNode as f, type LayoutOptions as g, type LayoutResult as h, type Graph as i, type BodyFloor as j, type BodyNodeSpec as k, type Bounds as l, type BuildBodyOptions as m, type BuildGraphOptions as n, DEFAULT_GROUP_INSET as o, DEFAULT_NODE_GAP as p, DEFAULT_PORTS as q, DEFAULT_RANK_GAP as r, DIAGRAM_TRAIT_KEY as s, type DiagramNodeEntry as t, type ForceBody as u, type ForceRelaxation as v, type Forest as w, type GraphEdge as x, type GraphGroup as y, type GraphNode as z };

package/dist/layout.js

@@ -1,3 +1,3 @@
-export { COMPASS, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, axesFor, backEdges, bodyOutline, boxForContent, buildBody, canvasMeasure, contentBox, extent, force, forceRelaxation, forestOf, graphOrder, layered, layoutBody, layoutRowPorts, measureBody, outlinePath, outlinePolyline, packAcross, pinnedSet, portOf, portsOf, portsOnOutline, ranksOf, rayHit, seededOrder, settle, sizeToBody, translated, tree } from './chunk-ERT3XWBS.js';
+export { COMPASS, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, axesFor, backEdges, bodyOutline, boxForContent, buildBody, canvasMeasure, contentBox, extent, force, forceRelaxation, forestOf, graphOrder, layered, layoutBody, layoutRowPorts, measureBody, outlinePath, outlinePolyline, packAcross, pinnedSet, portOf, portsOf, portsOnOutline, ranksOf, rayHit, seededOrder, settle, sizeToBody, translated, tree, untilSettled } from './chunk-BWQJYEA3.js';
 //# sourceMappingURL=layout.js.map
 //# sourceMappingURL=layout.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/diagram",
-  "version": "1.9.3",
+  "version": "1.10.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,8 +21,11 @@
   },
   "peerDependencies": {
     "react": ">=18",
-    "@weasel-js/core": "1.9.3",
-    "@weasel-js/geom": "1.9.3"
+    "@weasel-js/animator": "1.10.0",
+    "@weasel-js/core": "1.10.0",
+    "@weasel-js/font": "1.10.0",
+    "@weasel-js/geom": "1.10.0",
+    "@weasel-js/simulation": "1.10.0"
   },
   "author": "orochi235",
   "homepage": "https://orochi235.github.io/weasel/",