@flanksource/clicky-ui 0.3.40 → 0.3.42

package/dist/data/graph-columns-layout.cjs

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const graphEdgeRouting = require("./graph-edge-routing.cjs");
+const DEFAULT_NODE_WIDTH = 168;
+const DEFAULT_NODE_HEIGHT = 60;
+const DEFAULT_COLUMN_GAP = 96;
+const DEFAULT_ROW_GAP = 20;
+const DEFAULT_GROUP_PADDING = 12;
+const DEFAULT_PADDING = 24;
+const DEFAULT_SWEEPS = 4;
+function mustGet(map, key, what) {
+  const value = map.get(key);
+  if (value === void 0) {
+    throw new Error(`columnsLayout: no ${what} for "${String(key)}"`);
+  }
+  return value;
+}
+function columnMetrics(options) {
+  return {
+    nodeWidth: options.nodeWidth ?? DEFAULT_NODE_WIDTH,
+    nodeHeight: options.nodeHeight ?? DEFAULT_NODE_HEIGHT,
+    columnGap: options.columnGap ?? DEFAULT_COLUMN_GAP,
+    rowGap: options.rowGap ?? DEFAULT_ROW_GAP,
+    groupPadding: options.groupPadding ?? DEFAULT_GROUP_PADDING,
+    padding: options.padding ?? DEFAULT_PADDING,
+    sweeps: options.sweeps ?? DEFAULT_SWEEPS
+  };
+}
+function indexColumns(nodes) {
+  const columns = /* @__PURE__ */ new Map();
+  const groupRank = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (!Number.isFinite(node.level)) {
+      throw new Error(`columnsLayout: node "${node.id}" has no finite level (got ${node.level})`);
+    }
+    if (!groupRank.has(node.group)) groupRank.set(node.group, groupRank.size);
+    const column = columns.get(node.level);
+    if (column) {
+      column.push(node);
+    } else {
+      columns.set(node.level, [node]);
+    }
+  }
+  return { columns, groupRank };
+}
+function indexNeighbours(nodes, edges) {
+  const neighbours = new Map(nodes.map((node) => [node.id, []]));
+  for (const edge of edges) {
+    const from = neighbours.get(edge.from);
+    const to = neighbours.get(edge.to);
+    if (!from || !to) {
+      const missing = from ? edge.to : edge.from;
+      throw new Error(`columnsLayout: edge "${edge.id}" references unknown node "${missing}"`);
+    }
+    from.push(edge.to);
+    to.push(edge.from);
+  }
+  return neighbours;
+}
+function columnHeight(column, m) {
+  const groups = new Set(column.map((node) => node.group));
+  groups.delete(void 0);
+  return column.length * m.nodeHeight + (column.length - 1) * m.rowGap + 2 * m.groupPadding * groups.size;
+}
+function orderColumn(column, groupRank, weight) {
+  const runs = /* @__PURE__ */ new Map();
+  column.forEach((node, index) => {
+    const rank = mustGet(groupRank, node.group, "group rank");
+    const entry = { node, index, weight: weight(node) };
+    const run = runs.get(rank);
+    if (run) {
+      run.push(entry);
+    } else {
+      runs.set(rank, [entry]);
+    }
+  });
+  return [...runs.entries()].sort(([a], [b]) => a - b).map(([, run]) => {
+    var _a;
+    const nodes = run.sort((a, b) => a.weight - b.weight || a.index - b.index).map((entry) => entry.node);
+    return { group: (_a = nodes[0]) == null ? void 0 : _a.group, nodes };
+  });
+}
+function stackColumn(runs, origin, m, placed) {
+  const boxes = [];
+  let cursor = origin.top;
+  for (const { group, nodes } of runs) {
+    const pad = group === void 0 ? 0 : m.groupPadding;
+    const height = nodes.length * m.nodeHeight + (nodes.length - 1) * m.rowGap + 2 * pad;
+    nodes.forEach((node, index) => {
+      const top = cursor + pad + index * (m.nodeHeight + m.rowGap);
+      placed.set(node.id, { x: origin.x, y: top + m.nodeHeight / 2 });
+    });
+    if (group !== void 0) {
+      boxes.push({
+        id: `${origin.level}:${group}`,
+        group,
+        level: origin.level,
+        x: origin.x - m.nodeWidth / 2 - pad,
+        y: cursor,
+        width: m.nodeWidth + 2 * pad,
+        height
+      });
+    }
+    cursor += height + m.rowGap;
+  }
+  return boxes;
+}
+function meanY(ids, placed) {
+  if (ids.length === 0) return Number.POSITIVE_INFINITY;
+  return ids.reduce((sum, id) => sum + mustGet(placed, id, "position").y, 0) / ids.length;
+}
+function placementOrder(levels) {
+  const anchor = levels.reduce((best, level) => Math.abs(level) < Math.abs(best) ? level : best);
+  const outward = (side) => side.map((level, index) => [level, side[index - 1] ?? anchor]);
+  return [
+    [anchor, void 0],
+    ...outward(levels.filter((level) => level > anchor)),
+    ...outward(levels.filter((level) => level < anchor).reverse())
+  ];
+}
+function placeColumn(level, references, ctx, into) {
+  const runs = orderColumn(
+    mustGet(into.order, level, "column"),
+    ctx.groupRank,
+    (node) => meanY(
+      mustGet(ctx.neighbours, node.id, "neighbours").filter(
+        (id) => references.includes(mustGet(ctx.levelOf, id, "level"))
+      ),
+      into.placed
+    )
+  );
+  into.order.set(
+    level,
+    runs.flatMap((run) => run.nodes)
+  );
+  into.boxes.set(level, stackColumn(runs, ctx.origin(level), ctx.m, into.placed));
+}
+function countCrossings(ctx, placed) {
+  const spans = /* @__PURE__ */ new Map();
+  for (const edge of ctx.edges) {
+    const levels = [mustGet(ctx.levelOf, edge.from, "level"), mustGet(ctx.levelOf, edge.to, "level")];
+    const [lower, upper] = levels[0] < levels[1] ? [edge.from, edge.to] : [edge.to, edge.from];
+    const index = ctx.levels.indexOf(Math.min(...levels));
+    if (levels[0] === levels[1] || ctx.levels[index + 1] !== Math.max(...levels)) continue;
+    const span = [mustGet(placed, lower, "position").y, mustGet(placed, upper, "position").y];
+    spans.set(index, [...spans.get(index) ?? [], span]);
+  }
+  let crossings = 0;
+  for (const gap of spans.values()) {
+    gap.forEach((a, index) => {
+      crossings += gap.slice(index + 1).filter((b) => (a[0] - b[0]) * (a[1] - b[1]) < 0).length;
+    });
+  }
+  return crossings;
+}
+function sweep(from, sequence, ctx) {
+  const next = { order: new Map(from.order), placed: new Map(from.placed), boxes: new Map(from.boxes) };
+  for (const level of sequence) {
+    const index = ctx.levels.indexOf(level);
+    const adjacent = [ctx.levels[index - 1], ctx.levels[index + 1]].filter((other) => other !== void 0);
+    placeColumn(level, adjacent, ctx, next);
+  }
+  return next;
+}
+function arrange(columns, ctx) {
+  let current = { order: new Map(columns), placed: /* @__PURE__ */ new Map(), boxes: /* @__PURE__ */ new Map() };
+  for (const [level, reference] of placementOrder(ctx.levels)) {
+    placeColumn(level, reference === void 0 ? [] : [reference], ctx, current);
+  }
+  let best = current;
+  let fewest = countCrossings(ctx, best.placed);
+  for (let pass = 0; pass < ctx.m.sweeps && fewest > 0; pass++) {
+    current = sweep(current, pass % 2 === 0 ? [...ctx.levels].reverse() : ctx.levels, ctx);
+    const crossings = countCrossings(ctx, current.placed);
+    if (crossings < fewest) {
+      best = current;
+      fewest = crossings;
+    }
+  }
+  return best;
+}
+function columnsLayout(nodes, edges, options = {}) {
+  const m = columnMetrics(options);
+  const { columns, groupRank } = indexColumns(nodes);
+  const neighbours = indexNeighbours(nodes, edges);
+  const levels = [...columns.keys()].sort((a, b) => a - b);
+  if (levels.length === 0) {
+    return { width: 2 * m.padding, height: 2 * m.padding, positions: {}, groups: [] };
+  }
+  const minLevel = Math.min(...levels);
+  const tallest = Math.max(...[...columns.values()].map((column) => columnHeight(column, m)));
+  const inset = m.padding + (nodes.some((node) => node.group !== void 0) ? m.groupPadding : 0);
+  const { placed, boxes } = arrange(columns, {
+    m,
+    levels,
+    levelOf: new Map(nodes.map((node) => [node.id, node.level])),
+    groupRank,
+    neighbours,
+    edges,
+    origin: (level) => ({
+      x: inset + m.nodeWidth / 2 + (level - minLevel) * (m.nodeWidth + m.columnGap),
+      top: m.padding + (tallest - columnHeight(mustGet(columns, level, "column"), m)) / 2,
+      level
+    })
+  });
+  const room = graphEdgeRouting.loopOverhang(edges, Object.fromEntries(placed), m);
+  const span = (Math.max(...levels) - minLevel) * (m.nodeWidth + m.columnGap) + m.nodeWidth;
+  return {
+    width: room.left + 2 * inset + span + room.right,
+    height: tallest + 2 * m.padding,
+    positions: Object.fromEntries([...placed].map(([id, { x, y }]) => [id, { x: x + room.left, y }])),
+    groups: [...boxes.values()].flat().map((box) => ({ ...box, x: box.x + room.left })).sort((a, b) => a.level - b.level || a.y - b.y)
+  };
+}
+exports.columnsLayout = columnsLayout;
+//# sourceMappingURL=graph-columns-layout.cjs.map

package/dist/data/graph-columns-layout.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-columns-layout.cjs","sources":["../../src/data/graph-columns-layout.ts"],"sourcesContent":["// Level-column layout for GraphDiagram: pure math, no React. Split from\n// graph-layout.ts, which owns the shared types and `ringLayout`.\n\nimport { loopOverhang } from \"./graph-edge-routing\";\nimport type { GraphLayoutEdge, GraphLayoutNode, GraphLayoutPosition, GraphLayoutResult } from \"./graph-layout\";\n\nexport interface ColumnsLayoutNode extends GraphLayoutNode {\n  /** Column of the node. May be negative: the lowest level is the first column. */\n  level: number;\n  /** Nodes sharing a group stay contiguous within their column and are boxed together. */\n  group?: string;\n}\n\nexport interface ColumnsLayoutOptions {\n  /** Node bounding-box width in px. Defaults to 168. */\n  nodeWidth?: number;\n  /** Node bounding-box height in px. Defaults to 60. */\n  nodeHeight?: number;\n  /** Horizontal gap between the node boxes of adjacent columns in px. Defaults to 96. */\n  columnGap?: number;\n  /** Vertical gap between stacked nodes, and between group rectangles, in px. Defaults to 20. */\n  rowGap?: number;\n  /** Space between a group's nodes and its rectangle in px. Defaults to 12. */\n  groupPadding?: number;\n  /** Space reserved around the columns before the viewport edge. Defaults to 24. */\n  padding?: number;\n  /**\n   * Re-ordering passes over all columns after the first placement, alternating direction; a pass\n   * is kept only if it leaves fewer crossings. Defaults to 4. 0 keeps the first placement.\n   */\n  sweeps?: number;\n}\n\nexport interface GraphLayoutGroupBox {\n  /** `${level}:${group}` — a group spanning several columns gets one rectangle per column. */\n  id: string;\n  group: string;\n  level: number;\n  /** Top-left corner, in the same coordinate space as the layout's `width`/`height`. */\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\nexport interface ColumnsLayoutResult extends GraphLayoutResult {\n  groups: GraphLayoutGroupBox[];\n}\n\ntype ColumnMetrics = Required<ColumnsLayoutOptions>;\n\ninterface GroupRun {\n  group: string | undefined;\n  nodes: ColumnsLayoutNode[];\n}\n\n/** One ordering of every column, stacked: the node centres and group rectangles it gives. */\ninterface Arrangement {\n  order: Map<number, ColumnsLayoutNode[]>;\n  placed: Map<string, GraphLayoutPosition>;\n  boxes: Map<number, GraphLayoutGroupBox[]>;\n}\n\n/** What stays fixed while columns are re-ordered. */\ninterface ColumnsContext {\n  m: ColumnMetrics;\n  levels: number[];\n  levelOf: Map<string, number>;\n  groupRank: Map<string | undefined, number>;\n  neighbours: Map<string, string[]>;\n  edges: readonly GraphLayoutEdge[];\n  /** Centre x and top y of a level's column. */\n  origin: (level: number) => { x: number; top: number; level: number };\n}\n\nconst DEFAULT_NODE_WIDTH = 168;\nconst DEFAULT_NODE_HEIGHT = 60;\nconst DEFAULT_COLUMN_GAP = 96;\nconst DEFAULT_ROW_GAP = 20;\nconst DEFAULT_GROUP_PADDING = 12;\nconst DEFAULT_PADDING = 24;\nconst DEFAULT_SWEEPS = 4;\n\nfunction mustGet<K, V>(map: ReadonlyMap<K, V>, key: K, what: string): V {\n  const value = map.get(key);\n  if (value === undefined) {\n    throw new Error(`columnsLayout: no ${what} for \"${String(key)}\"`);\n  }\n  return value;\n}\n\nfunction columnMetrics(options: ColumnsLayoutOptions): ColumnMetrics {\n  return {\n    nodeWidth: options.nodeWidth ?? DEFAULT_NODE_WIDTH,\n    nodeHeight: options.nodeHeight ?? DEFAULT_NODE_HEIGHT,\n    columnGap: options.columnGap ?? DEFAULT_COLUMN_GAP,\n    rowGap: options.rowGap ?? DEFAULT_ROW_GAP,\n    groupPadding: options.groupPadding ?? DEFAULT_GROUP_PADDING,\n    padding: options.padding ?? DEFAULT_PADDING,\n    sweeps: options.sweeps ?? DEFAULT_SWEEPS,\n  };\n}\n\nfunction indexColumns(nodes: readonly ColumnsLayoutNode[]) {\n  const columns = new Map<number, ColumnsLayoutNode[]>();\n  const groupRank = new Map<string | undefined, number>();\n  for (const node of nodes) {\n    if (!Number.isFinite(node.level)) {\n      throw new Error(`columnsLayout: node \"${node.id}\" has no finite level (got ${node.level})`);\n    }\n    if (!groupRank.has(node.group)) groupRank.set(node.group, groupRank.size);\n    const column = columns.get(node.level);\n    if (column) {\n      column.push(node);\n    } else {\n      columns.set(node.level, [node]);\n    }\n  }\n  return { columns, groupRank };\n}\n\nfunction indexNeighbours(\n  nodes: readonly ColumnsLayoutNode[],\n  edges: readonly GraphLayoutEdge[],\n): Map<string, string[]> {\n  const neighbours = new Map<string, string[]>(nodes.map((node) => [node.id, []]));\n  for (const edge of edges) {\n    const from = neighbours.get(edge.from);\n    const to = neighbours.get(edge.to);\n    if (!from || !to) {\n      const missing = from ? edge.to : edge.from;\n      throw new Error(`columnsLayout: edge \"${edge.id}\" references unknown node \"${missing}\"`);\n    }\n    from.push(edge.to);\n    to.push(edge.from);\n  }\n  return neighbours;\n}\n\nfunction columnHeight(column: readonly ColumnsLayoutNode[], m: ColumnMetrics): number {\n  const groups = new Set(column.map((node) => node.group));\n  groups.delete(undefined);\n  return column.length * m.nodeHeight + (column.length - 1) * m.rowGap + 2 * m.groupPadding * groups.size;\n}\n\n/** Groups in order of first appearance; within a group by ascending weight, the column's order on ties. */\nfunction orderColumn(\n  column: readonly ColumnsLayoutNode[],\n  groupRank: ReadonlyMap<string | undefined, number>,\n  weight: (node: ColumnsLayoutNode) => number,\n): GroupRun[] {\n  const runs = new Map<number, { node: ColumnsLayoutNode; index: number; weight: number }[]>();\n  column.forEach((node, index) => {\n    const rank = mustGet(groupRank, node.group, \"group rank\");\n    const entry = { node, index, weight: weight(node) };\n    const run = runs.get(rank);\n    if (run) {\n      run.push(entry);\n    } else {\n      runs.set(rank, [entry]);\n    }\n  });\n  return [...runs.entries()]\n    .sort(([a], [b]) => a - b)\n    .map(([, run]) => {\n      // Infinity - Infinity is NaN, which falls through to the column-order tiebreak.\n      const nodes = run.sort((a, b) => a.weight - b.weight || a.index - b.index).map((entry) => entry.node);\n      return { group: nodes[0]?.group, nodes };\n    });\n}\n\nfunction stackColumn(\n  runs: readonly GroupRun[],\n  origin: { x: number; top: number; level: number },\n  m: ColumnMetrics,\n  placed: Map<string, GraphLayoutPosition>,\n): GraphLayoutGroupBox[] {\n  const boxes: GraphLayoutGroupBox[] = [];\n  let cursor = origin.top;\n  for (const { group, nodes } of runs) {\n    const pad = group === undefined ? 0 : m.groupPadding;\n    const height = nodes.length * m.nodeHeight + (nodes.length - 1) * m.rowGap + 2 * pad;\n    nodes.forEach((node, index) => {\n      const top = cursor + pad + index * (m.nodeHeight + m.rowGap);\n      placed.set(node.id, { x: origin.x, y: top + m.nodeHeight / 2 });\n    });\n    if (group !== undefined) {\n      boxes.push({\n        id: `${origin.level}:${group}`,\n        group,\n        level: origin.level,\n        x: origin.x - m.nodeWidth / 2 - pad,\n        y: cursor,\n        width: m.nodeWidth + 2 * pad,\n        height,\n      });\n    }\n    cursor += height + m.rowGap;\n  }\n  return boxes;\n}\n\nfunction meanY(ids: readonly string[], placed: ReadonlyMap<string, GraphLayoutPosition>): number {\n  if (ids.length === 0) return Number.POSITIVE_INFINITY;\n  return ids.reduce((sum, id) => sum + mustGet(placed, id, \"position\").y, 0) / ids.length;\n}\n\n/**\n * Levels in the order they are first laid out — the one nearest 0, then\n * outward on each side — each paired with the already-placed adjacent level\n * its nodes are ordered against.\n */\nfunction placementOrder(levels: readonly number[]): [level: number, reference: number | undefined][] {\n  const anchor = levels.reduce((best, level) => (Math.abs(level) < Math.abs(best) ? level : best));\n  const outward = (side: readonly number[]) =>\n    side.map((level, index): [number, number] => [level, side[index - 1] ?? anchor]);\n  return [\n    [anchor, undefined],\n    ...outward(levels.filter((level) => level > anchor)),\n    ...outward(levels.filter((level) => level < anchor).reverse()),\n  ];\n}\n\n/** Orders one column by the mean y of its nodes' neighbours in the `references` levels, and stacks it. */\nfunction placeColumn(level: number, references: readonly number[], ctx: ColumnsContext, into: Arrangement): void {\n  const runs = orderColumn(mustGet(into.order, level, \"column\"), ctx.groupRank, (node) =>\n    meanY(\n      mustGet(ctx.neighbours, node.id, \"neighbours\").filter((id) =>\n        references.includes(mustGet(ctx.levelOf, id, \"level\")),\n      ),\n      into.placed,\n    ),\n  );\n  into.order.set(\n    level,\n    runs.flatMap((run) => run.nodes),\n  );\n  into.boxes.set(level, stackColumn(runs, ctx.origin(level), ctx.m, into.placed));\n}\n\n/** Pairs of edges between adjacent columns that cross, taking each edge as a straight line. */\nfunction countCrossings(ctx: ColumnsContext, placed: ReadonlyMap<string, GraphLayoutPosition>): number {\n  const spans = new Map<number, [lower: number, upper: number][]>();\n  for (const edge of ctx.edges) {\n    const levels = [mustGet(ctx.levelOf, edge.from, \"level\"), mustGet(ctx.levelOf, edge.to, \"level\")] as const;\n    const [lower, upper] = levels[0] < levels[1] ? [edge.from, edge.to] : [edge.to, edge.from];\n    const index = ctx.levels.indexOf(Math.min(...levels));\n    if (levels[0] === levels[1] || ctx.levels[index + 1] !== Math.max(...levels)) continue;\n    const span: [number, number] = [mustGet(placed, lower, \"position\").y, mustGet(placed, upper, \"position\").y];\n    spans.set(index, [...(spans.get(index) ?? []), span]);\n  }\n  let crossings = 0;\n  for (const gap of spans.values()) {\n    gap.forEach((a, index) => {\n      crossings += gap.slice(index + 1).filter((b) => (a[0] - b[0]) * (a[1] - b[1]) < 0).length;\n    });\n  }\n  return crossings;\n}\n\n/** A copy of `from` with every column re-ordered against both its neighbours, in the order given. */\nfunction sweep(from: Arrangement, sequence: readonly number[], ctx: ColumnsContext): Arrangement {\n  const next: Arrangement = { order: new Map(from.order), placed: new Map(from.placed), boxes: new Map(from.boxes) };\n  for (const level of sequence) {\n    const index = ctx.levels.indexOf(level);\n    const adjacent = [ctx.levels[index - 1], ctx.levels[index + 1]].filter((other): other is number => other !== undefined);\n    placeColumn(level, adjacent, ctx, next);\n  }\n  return next;\n}\n\n/**\n * Orders the columns. The first pass places the level nearest 0 and works\n * outward, ordering each column against the one just placed. Then up to\n * `sweeps` passes re-order every column against both its neighbours, inward\n * then outward, and the arrangement with the fewest crossings is kept: the\n * first pass's unless a later one strictly beats it.\n */\nfunction arrange(columns: ReadonlyMap<number, ColumnsLayoutNode[]>, ctx: ColumnsContext): Arrangement {\n  let current: Arrangement = { order: new Map(columns), placed: new Map(), boxes: new Map() };\n  for (const [level, reference] of placementOrder(ctx.levels)) {\n    placeColumn(level, reference === undefined ? [] : [reference], ctx, current);\n  }\n  let best = current;\n  let fewest = countCrossings(ctx, best.placed);\n  for (let pass = 0; pass < ctx.m.sweeps && fewest > 0; pass++) {\n    current = sweep(current, pass % 2 === 0 ? [...ctx.levels].reverse() : ctx.levels, ctx);\n    const crossings = countCrossings(ctx, current.placed);\n    if (crossings < fewest) {\n      best = current;\n      fewest = crossings;\n    }\n  }\n  return best;\n}\n\n/**\n * Places nodes in left-to-right columns by `level` (the lowest level first),\n * stacking each column top to bottom and centring it against the tallest one.\n *\n * Within a column, nodes of one group are contiguous, groups appearing in the\n * order they first occur in `nodes`. Inside a group nodes are ordered by the\n * mean y of their neighbours in the adjacent columns, so edges between columns\n * cross less (see `arrange`); nodes with no neighbour there go last, and ties\n * keep input order.\n *\n * Returns node centres plus one rectangle per (column, group). Extra width is\n * reserved on each side for the loops `routeEdges` draws outside the first and\n * last columns.\n */\nexport function columnsLayout(\n  nodes: readonly ColumnsLayoutNode[],\n  edges: readonly GraphLayoutEdge[],\n  options: ColumnsLayoutOptions = {},\n): ColumnsLayoutResult {\n  const m = columnMetrics(options);\n  const { columns, groupRank } = indexColumns(nodes);\n  const neighbours = indexNeighbours(nodes, edges);\n  const levels = [...columns.keys()].sort((a, b) => a - b);\n  if (levels.length === 0) {\n    return { width: 2 * m.padding, height: 2 * m.padding, positions: {}, groups: [] };\n  }\n\n  const minLevel = Math.min(...levels);\n  const tallest = Math.max(...[...columns.values()].map((column) => columnHeight(column, m)));\n  const inset = m.padding + (nodes.some((node) => node.group !== undefined) ? m.groupPadding : 0);\n  const { placed, boxes } = arrange(columns, {\n    m,\n    levels,\n    levelOf: new Map(nodes.map((node) => [node.id, node.level])),\n    groupRank,\n    neighbours,\n    edges,\n    origin: (level) => ({\n      x: inset + m.nodeWidth / 2 + (level - minLevel) * (m.nodeWidth + m.columnGap),\n      top: m.padding + (tallest - columnHeight(mustGet(columns, level, \"column\"), m)) / 2,\n      level,\n    }),\n  });\n\n  const room = loopOverhang(edges, Object.fromEntries(placed), m);\n  const span = (Math.max(...levels) - minLevel) * (m.nodeWidth + m.columnGap) + m.nodeWidth;\n  return {\n    width: room.left + 2 * inset + span + room.right,\n    height: tallest + 2 * m.padding,\n    positions: Object.fromEntries([...placed].map(([id, { x, y }]) => [id, { x: x + room.left, y }])),\n    groups: [...boxes.values()]\n      .flat()\n      .map((box) => ({ ...box, x: box.x + room.left }))\n      .sort((a, b) => a.level - b.level || a.y - b.y),\n  };\n}\n"],"names":["loopOverhang"],"mappings":";;;AA2EA,MAAM,qBAAqB;AAC3B,MAAM,sBAAsB;AAC5B,MAAM,qBAAqB;AAC3B,MAAM,kBAAkB;AACxB,MAAM,wBAAwB;AAC9B,MAAM,kBAAkB;AACxB,MAAM,iBAAiB;AAEvB,SAAS,QAAc,KAAwB,KAAQ,MAAiB;AACtE,QAAM,QAAQ,IAAI,IAAI,GAAG;AACzB,MAAI,UAAU,QAAW;AACvB,UAAM,IAAI,MAAM,qBAAqB,IAAI,SAAS,OAAO,GAAG,CAAC,GAAG;AAAA,EAClE;AACA,SAAO;AACT;AAEA,SAAS,cAAc,SAA8C;AACnE,SAAO;AAAA,IACL,WAAW,QAAQ,aAAa;AAAA,IAChC,YAAY,QAAQ,cAAc;AAAA,IAClC,WAAW,QAAQ,aAAa;AAAA,IAChC,QAAQ,QAAQ,UAAU;AAAA,IAC1B,cAAc,QAAQ,gBAAgB;AAAA,IACtC,SAAS,QAAQ,WAAW;AAAA,IAC5B,QAAQ,QAAQ,UAAU;AAAA,EAAA;AAE9B;AAEA,SAAS,aAAa,OAAqC;AACzD,QAAM,8BAAc,IAAA;AACpB,QAAM,gCAAgB,IAAA;AACtB,aAAW,QAAQ,OAAO;AACxB,QAAI,CAAC,OAAO,SAAS,KAAK,KAAK,GAAG;AAChC,YAAM,IAAI,MAAM,wBAAwB,KAAK,EAAE,8BAA8B,KAAK,KAAK,GAAG;AAAA,IAC5F;AACA,QAAI,CAAC,UAAU,IAAI,KAAK,KAAK,EAAG,WAAU,IAAI,KAAK,OAAO,UAAU,IAAI;AACxE,UAAM,SAAS,QAAQ,IAAI,KAAK,KAAK;AACrC,QAAI,QAAQ;AACV,aAAO,KAAK,IAAI;AAAA,IAClB,OAAO;AACL,cAAQ,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC;AAAA,IAChC;AAAA,EACF;AACA,SAAO,EAAE,SAAS,UAAA;AACpB;AAEA,SAAS,gBACP,OACA,OACuB;AACvB,QAAM,aAAa,IAAI,IAAsB,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,IAAI,CAAA,CAAE,CAAC,CAAC;AAC/E,aAAW,QAAQ,OAAO;AACxB,UAAM,OAAO,WAAW,IAAI,KAAK,IAAI;AACrC,UAAM,KAAK,WAAW,IAAI,KAAK,EAAE;AACjC,QAAI,CAAC,QAAQ,CAAC,IAAI;AAChB,YAAM,UAAU,OAAO,KAAK,KAAK,KAAK;AACtC,YAAM,IAAI,MAAM,wBAAwB,KAAK,EAAE,8BAA8B,OAAO,GAAG;AAAA,IACzF;AACA,SAAK,KAAK,KAAK,EAAE;AACjB,OAAG,KAAK,KAAK,IAAI;AAAA,EACnB;AACA,SAAO;AACT;AAEA,SAAS,aAAa,QAAsC,GAA0B;AACpF,QAAM,SAAS,IAAI,IAAI,OAAO,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC;AACvD,SAAO,OAAO,MAAS;AACvB,SAAO,OAAO,SAAS,EAAE,cAAc,OAAO,SAAS,KAAK,EAAE,SAAS,IAAI,EAAE,eAAe,OAAO;AACrG;AAGA,SAAS,YACP,QACA,WACA,QACY;AACZ,QAAM,2BAAW,IAAA;AACjB,SAAO,QAAQ,CAAC,MAAM,UAAU;AAC9B,UAAM,OAAO,QAAQ,WAAW,KAAK,OAAO,YAAY;AACxD,UAAM,QAAQ,EAAE,MAAM,OAAO,QAAQ,OAAO,IAAI,EAAA;AAChD,UAAM,MAAM,KAAK,IAAI,IAAI;AACzB,QAAI,KAAK;AACP,UAAI,KAAK,KAAK;AAAA,IAChB,OAAO;AACL,WAAK,IAAI,MAAM,CAAC,KAAK,CAAC;AAAA,IACxB;AAAA,EACF,CAAC;AACD,SAAO,CAAC,GAAG,KAAK,QAAA,CAAS,EACtB,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,IAAI,CAAC,EACxB,IAAI,CAAC,CAAA,EAAG,GAAG,MAAM;;AAEhB,UAAM,QAAQ,IAAI,KAAK,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,CAAC,UAAU,MAAM,IAAI;AACpG,WAAO,EAAE,QAAO,WAAM,CAAC,MAAP,mBAAU,OAAO,MAAA;AAAA,EACnC,CAAC;AACL;AAEA,SAAS,YACP,MACA,QACA,GACA,QACuB;AACvB,QAAM,QAA+B,CAAA;AACrC,MAAI,SAAS,OAAO;AACpB,aAAW,EAAE,OAAO,MAAA,KAAW,MAAM;AACnC,UAAM,MAAM,UAAU,SAAY,IAAI,EAAE;AACxC,UAAM,SAAS,MAAM,SAAS,EAAE,cAAc,MAAM,SAAS,KAAK,EAAE,SAAS,IAAI;AACjF,UAAM,QAAQ,CAAC,MAAM,UAAU;AAC7B,YAAM,MAAM,SAAS,MAAM,SAAS,EAAE,aAAa,EAAE;AACrD,aAAO,IAAI,KAAK,IAAI,EAAE,GAAG,OAAO,GAAG,GAAG,MAAM,EAAE,aAAa,EAAA,CAAG;AAAA,IAChE,CAAC;AACD,QAAI,UAAU,QAAW;AACvB,YAAM,KAAK;AAAA,QACT,IAAI,GAAG,OAAO,KAAK,IAAI,KAAK;AAAA,QAC5B;AAAA,QACA,OAAO,OAAO;AAAA,QACd,GAAG,OAAO,IAAI,EAAE,YAAY,IAAI;AAAA,QAChC,GAAG;AAAA,QACH,OAAO,EAAE,YAAY,IAAI;AAAA,QACzB;AAAA,MAAA,CACD;AAAA,IACH;AACA,cAAU,SAAS,EAAE;AAAA,EACvB;AACA,SAAO;AACT;AAEA,SAAS,MAAM,KAAwB,QAA0D;AAC/F,MAAI,IAAI,WAAW,EAAG,QAAO,OAAO;AACpC,SAAO,IAAI,OAAO,CAAC,KAAK,OAAO,MAAM,QAAQ,QAAQ,IAAI,UAAU,EAAE,GAAG,CAAC,IAAI,IAAI;AACnF;AAOA,SAAS,eAAe,QAA6E;AACnG,QAAM,SAAS,OAAO,OAAO,CAAC,MAAM,UAAW,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,IAAI,IAAI,QAAQ,IAAK;AAC/F,QAAM,UAAU,CAAC,SACf,KAAK,IAAI,CAAC,OAAO,UAA4B,CAAC,OAAO,KAAK,QAAQ,CAAC,KAAK,MAAM,CAAC;AACjF,SAAO;AAAA,IACL,CAAC,QAAQ,MAAS;AAAA,IAClB,GAAG,QAAQ,OAAO,OAAO,CAAC,UAAU,QAAQ,MAAM,CAAC;AAAA,IACnD,GAAG,QAAQ,OAAO,OAAO,CAAC,UAAU,QAAQ,MAAM,EAAE,QAAA,CAAS;AAAA,EAAA;AAEjE;AAGA,SAAS,YAAY,OAAe,YAA+B,KAAqB,MAAyB;AAC/G,QAAM,OAAO;AAAA,IAAY,QAAQ,KAAK,OAAO,OAAO,QAAQ;AAAA,IAAG,IAAI;AAAA,IAAW,CAAC,SAC7E;AAAA,MACE,QAAQ,IAAI,YAAY,KAAK,IAAI,YAAY,EAAE;AAAA,QAAO,CAAC,OACrD,WAAW,SAAS,QAAQ,IAAI,SAAS,IAAI,OAAO,CAAC;AAAA,MAAA;AAAA,MAEvD,KAAK;AAAA,IAAA;AAAA,EACP;AAEF,OAAK,MAAM;AAAA,IACT;AAAA,IACA,KAAK,QAAQ,CAAC,QAAQ,IAAI,KAAK;AAAA,EAAA;AAEjC,OAAK,MAAM,IAAI,OAAO,YAAY,MAAM,IAAI,OAAO,KAAK,GAAG,IAAI,GAAG,KAAK,MAAM,CAAC;AAChF;AAGA,SAAS,eAAe,KAAqB,QAA0D;AACrG,QAAM,4BAAY,IAAA;AAClB,aAAW,QAAQ,IAAI,OAAO;AAC5B,UAAM,SAAS,CAAC,QAAQ,IAAI,SAAS,KAAK,MAAM,OAAO,GAAG,QAAQ,IAAI,SAAS,KAAK,IAAI,OAAO,CAAC;AAChG,UAAM,CAAC,OAAO,KAAK,IAAI,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,MAAM,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,KAAK,IAAI;AACzF,UAAM,QAAQ,IAAI,OAAO,QAAQ,KAAK,IAAI,GAAG,MAAM,CAAC;AACpD,QAAI,OAAO,CAAC,MAAM,OAAO,CAAC,KAAK,IAAI,OAAO,QAAQ,CAAC,MAAM,KAAK,IAAI,GAAG,MAAM,EAAG;AAC9E,UAAM,OAAyB,CAAC,QAAQ,QAAQ,OAAO,UAAU,EAAE,GAAG,QAAQ,QAAQ,OAAO,UAAU,EAAE,CAAC;AAC1G,UAAM,IAAI,OAAO,CAAC,GAAI,MAAM,IAAI,KAAK,KAAK,IAAK,IAAI,CAAC;AAAA,EACtD;AACA,MAAI,YAAY;AAChB,aAAW,OAAO,MAAM,UAAU;AAChC,QAAI,QAAQ,CAAC,GAAG,UAAU;AACxB,mBAAa,IAAI,MAAM,QAAQ,CAAC,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,EAAE;AAAA,IACrF,CAAC;AAAA,EACH;AACA,SAAO;AACT;AAGA,SAAS,MAAM,MAAmB,UAA6B,KAAkC;AAC/F,QAAM,OAAoB,EAAE,OAAO,IAAI,IAAI,KAAK,KAAK,GAAG,QAAQ,IAAI,IAAI,KAAK,MAAM,GAAG,OAAO,IAAI,IAAI,KAAK,KAAK,EAAA;AAC/G,aAAW,SAAS,UAAU;AAC5B,UAAM,QAAQ,IAAI,OAAO,QAAQ,KAAK;AACtC,UAAM,WAAW,CAAC,IAAI,OAAO,QAAQ,CAAC,GAAG,IAAI,OAAO,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC,UAA2B,UAAU,MAAS;AACtH,gBAAY,OAAO,UAAU,KAAK,IAAI;AAAA,EACxC;AACA,SAAO;AACT;AASA,SAAS,QAAQ,SAAmD,KAAkC;AACpG,MAAI,UAAuB,EAAE,OAAO,IAAI,IAAI,OAAO,GAAG,QAAQ,oBAAI,IAAA,GAAO,OAAO,oBAAI,MAAI;AACxF,aAAW,CAAC,OAAO,SAAS,KAAK,eAAe,IAAI,MAAM,GAAG;AAC3D,gBAAY,OAAO,cAAc,SAAY,CAAA,IAAK,CAAC,SAAS,GAAG,KAAK,OAAO;AAAA,EAC7E;AACA,MAAI,OAAO;AACX,MAAI,SAAS,eAAe,KAAK,KAAK,MAAM;AAC5C,WAAS,OAAO,GAAG,OAAO,IAAI,EAAE,UAAU,SAAS,GAAG,QAAQ;AAC5D,cAAU,MAAM,SAAS,OAAO,MAAM,IAAI,CAAC,GAAG,IAAI,MAAM,EAAE,QAAA,IAAY,IAAI,QAAQ,GAAG;AACrF,UAAM,YAAY,eAAe,KAAK,QAAQ,MAAM;AACpD,QAAI,YAAY,QAAQ;AACtB,aAAO;AACP,eAAS;AAAA,IACX;AAAA,EACF;AACA,SAAO;AACT;AAgBO,SAAS,cACd,OACA,OACA,UAAgC,CAAA,GACX;AACrB,QAAM,IAAI,cAAc,OAAO;AAC/B,QAAM,EAAE,SAAS,cAAc,aAAa,KAAK;AACjD,QAAM,aAAa,gBAAgB,OAAO,KAAK;AAC/C,QAAM,SAAS,CAAC,GAAG,QAAQ,KAAA,CAAM,EAAE,KAAK,CAAC,GAAG,MAAM,IAAI,CAAC;AACvD,MAAI,OAAO,WAAW,GAAG;AACvB,WAAO,EAAE,OAAO,IAAI,EAAE,SAAS,QAAQ,IAAI,EAAE,SAAS,WAAW,CAAA,GAAI,QAAQ,CAAA,EAAC;AAAA,EAChF;AAEA,QAAM,WAAW,KAAK,IAAI,GAAG,MAAM;AACnC,QAAM,UAAU,KAAK,IAAI,GAAG,CAAC,GAAG,QAAQ,OAAA,CAAQ,EAAE,IAAI,CAAC,WAAW,aAAa,QAAQ,CAAC,CAAC,CAAC;AAC1F,QAAM,QAAQ,EAAE,WAAW,MAAM,KAAK,CAAC,SAAS,KAAK,UAAU,MAAS,IAAI,EAAE,eAAe;AAC7F,QAAM,EAAE,QAAQ,UAAU,QAAQ,SAAS;AAAA,IACzC;AAAA,IACA;AAAA,IACA,SAAS,IAAI,IAAI,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,IAAI,KAAK,KAAK,CAAC,CAAC;AAAA,IAC3D;AAAA,IACA;AAAA,IACA;AAAA,IACA,QAAQ,CAAC,WAAW;AAAA,MAClB,GAAG,QAAQ,EAAE,YAAY,KAAK,QAAQ,aAAa,EAAE,YAAY,EAAE;AAAA,MACnE,KAAK,EAAE,WAAW,UAAU,aAAa,QAAQ,SAAS,OAAO,QAAQ,GAAG,CAAC,KAAK;AAAA,MAClF;AAAA,IAAA;AAAA,EACF,CACD;AAED,QAAM,OAAOA,iBAAAA,aAAa,OAAO,OAAO,YAAY,MAAM,GAAG,CAAC;AAC9D,QAAM,QAAQ,KAAK,IAAI,GAAG,MAAM,IAAI,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE;AAChF,SAAO;AAAA,IACL,OAAO,KAAK,OAAO,IAAI,QAAQ,OAAO,KAAK;AAAA,IAC3C,QAAQ,UAAU,IAAI,EAAE;AAAA,IACxB,WAAW,OAAO,YAAY,CAAC,GAAG,MAAM,EAAE,IAAI,CAAC,CAAC,IAAI,EAAE,GAAG,GAAG,MAAM,CAAC,IAAI,EAAE,GAAG,IAAI,KAAK,MAAM,EAAA,CAAG,CAAC,CAAC;AAAA,IAChG,QAAQ,CAAC,GAAG,MAAM,QAAQ,EACvB,KAAA,EACA,IAAI,CAAC,SAAS,EAAE,GAAG,KAAK,GAAG,IAAI,IAAI,KAAK,KAAA,EAAO,EAC/C,KAAK,CAAC,GAAG,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;AAAA,EAAA;AAEpD;;"}

package/dist/data/graph-columns-layout.d.ts

@@ -0,0 +1,56 @@
+import { GraphLayoutEdge, GraphLayoutNode, GraphLayoutResult } from './graph-layout.js';
+export interface ColumnsLayoutNode extends GraphLayoutNode {
+    /** Column of the node. May be negative: the lowest level is the first column. */
+    level: number;
+    /** Nodes sharing a group stay contiguous within their column and are boxed together. */
+    group?: string;
+}
+export interface ColumnsLayoutOptions {
+    /** Node bounding-box width in px. Defaults to 168. */
+    nodeWidth?: number;
+    /** Node bounding-box height in px. Defaults to 60. */
+    nodeHeight?: number;
+    /** Horizontal gap between the node boxes of adjacent columns in px. Defaults to 96. */
+    columnGap?: number;
+    /** Vertical gap between stacked nodes, and between group rectangles, in px. Defaults to 20. */
+    rowGap?: number;
+    /** Space between a group's nodes and its rectangle in px. Defaults to 12. */
+    groupPadding?: number;
+    /** Space reserved around the columns before the viewport edge. Defaults to 24. */
+    padding?: number;
+    /**
+     * Re-ordering passes over all columns after the first placement, alternating direction; a pass
+     * is kept only if it leaves fewer crossings. Defaults to 4. 0 keeps the first placement.
+     */
+    sweeps?: number;
+}
+export interface GraphLayoutGroupBox {
+    /** `${level}:${group}` — a group spanning several columns gets one rectangle per column. */
+    id: string;
+    group: string;
+    level: number;
+    /** Top-left corner, in the same coordinate space as the layout's `width`/`height`. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface ColumnsLayoutResult extends GraphLayoutResult {
+    groups: GraphLayoutGroupBox[];
+}
+/**
+ * Places nodes in left-to-right columns by `level` (the lowest level first),
+ * stacking each column top to bottom and centring it against the tallest one.
+ *
+ * Within a column, nodes of one group are contiguous, groups appearing in the
+ * order they first occur in `nodes`. Inside a group nodes are ordered by the
+ * mean y of their neighbours in the adjacent columns, so edges between columns
+ * cross less (see `arrange`); nodes with no neighbour there go last, and ties
+ * keep input order.
+ *
+ * Returns node centres plus one rectangle per (column, group). Extra width is
+ * reserved on each side for the loops `routeEdges` draws outside the first and
+ * last columns.
+ */
+export declare function columnsLayout(nodes: readonly ColumnsLayoutNode[], edges: readonly GraphLayoutEdge[], options?: ColumnsLayoutOptions): ColumnsLayoutResult;
+//# sourceMappingURL=graph-columns-layout.d.ts.map

package/dist/data/graph-columns-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-columns-layout.d.ts","sourceRoot":"","sources":["../../src/data/graph-columns-layout.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAuB,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAE/G,MAAM,WAAW,iBAAkB,SAAQ,eAAe;IACxD,iFAAiF;IACjF,KAAK,EAAE,MAAM,CAAC;IACd,wFAAwF;IACxF,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACnC,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uFAAuF;IACvF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+FAA+F;IAC/F,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kFAAkF;IAClF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,4FAA4F;IAC5F,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,sFAAsF;IACtF,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAoB,SAAQ,iBAAiB;IAC5D,MAAM,EAAE,mBAAmB,EAAE,CAAC;CAC/B;AAyPD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,SAAS,iBAAiB,EAAE,EACnC,KAAK,EAAE,SAAS,eAAe,EAAE,EACjC,OAAO,GAAE,oBAAyB,GACjC,mBAAmB,CAqCrB"}

package/dist/data/graph-columns-layout.js

@@ -0,0 +1,216 @@
+import { loopOverhang } from "./graph-edge-routing.js";
+const DEFAULT_NODE_WIDTH = 168;
+const DEFAULT_NODE_HEIGHT = 60;
+const DEFAULT_COLUMN_GAP = 96;
+const DEFAULT_ROW_GAP = 20;
+const DEFAULT_GROUP_PADDING = 12;
+const DEFAULT_PADDING = 24;
+const DEFAULT_SWEEPS = 4;
+function mustGet(map, key, what) {
+  const value = map.get(key);
+  if (value === void 0) {
+    throw new Error(`columnsLayout: no ${what} for "${String(key)}"`);
+  }
+  return value;
+}
+function columnMetrics(options) {
+  return {
+    nodeWidth: options.nodeWidth ?? DEFAULT_NODE_WIDTH,
+    nodeHeight: options.nodeHeight ?? DEFAULT_NODE_HEIGHT,
+    columnGap: options.columnGap ?? DEFAULT_COLUMN_GAP,
+    rowGap: options.rowGap ?? DEFAULT_ROW_GAP,
+    groupPadding: options.groupPadding ?? DEFAULT_GROUP_PADDING,
+    padding: options.padding ?? DEFAULT_PADDING,
+    sweeps: options.sweeps ?? DEFAULT_SWEEPS
+  };
+}
+function indexColumns(nodes) {
+  const columns = /* @__PURE__ */ new Map();
+  const groupRank = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (!Number.isFinite(node.level)) {
+      throw new Error(`columnsLayout: node "${node.id}" has no finite level (got ${node.level})`);
+    }
+    if (!groupRank.has(node.group)) groupRank.set(node.group, groupRank.size);
+    const column = columns.get(node.level);
+    if (column) {
+      column.push(node);
+    } else {
+      columns.set(node.level, [node]);
+    }
+  }
+  return { columns, groupRank };
+}
+function indexNeighbours(nodes, edges) {
+  const neighbours = new Map(nodes.map((node) => [node.id, []]));
+  for (const edge of edges) {
+    const from = neighbours.get(edge.from);
+    const to = neighbours.get(edge.to);
+    if (!from || !to) {
+      const missing = from ? edge.to : edge.from;
+      throw new Error(`columnsLayout: edge "${edge.id}" references unknown node "${missing}"`);
+    }
+    from.push(edge.to);
+    to.push(edge.from);
+  }
+  return neighbours;
+}
+function columnHeight(column, m) {
+  const groups = new Set(column.map((node) => node.group));
+  groups.delete(void 0);
+  return column.length * m.nodeHeight + (column.length - 1) * m.rowGap + 2 * m.groupPadding * groups.size;
+}
+function orderColumn(column, groupRank, weight) {
+  const runs = /* @__PURE__ */ new Map();
+  column.forEach((node, index) => {
+    const rank = mustGet(groupRank, node.group, "group rank");
+    const entry = { node, index, weight: weight(node) };
+    const run = runs.get(rank);
+    if (run) {
+      run.push(entry);
+    } else {
+      runs.set(rank, [entry]);
+    }
+  });
+  return [...runs.entries()].sort(([a], [b]) => a - b).map(([, run]) => {
+    var _a;
+    const nodes = run.sort((a, b) => a.weight - b.weight || a.index - b.index).map((entry) => entry.node);
+    return { group: (_a = nodes[0]) == null ? void 0 : _a.group, nodes };
+  });
+}
+function stackColumn(runs, origin, m, placed) {
+  const boxes = [];
+  let cursor = origin.top;
+  for (const { group, nodes } of runs) {
+    const pad = group === void 0 ? 0 : m.groupPadding;
+    const height = nodes.length * m.nodeHeight + (nodes.length - 1) * m.rowGap + 2 * pad;
+    nodes.forEach((node, index) => {
+      const top = cursor + pad + index * (m.nodeHeight + m.rowGap);
+      placed.set(node.id, { x: origin.x, y: top + m.nodeHeight / 2 });
+    });
+    if (group !== void 0) {
+      boxes.push({
+        id: `${origin.level}:${group}`,
+        group,
+        level: origin.level,
+        x: origin.x - m.nodeWidth / 2 - pad,
+        y: cursor,
+        width: m.nodeWidth + 2 * pad,
+        height
+      });
+    }
+    cursor += height + m.rowGap;
+  }
+  return boxes;
+}
+function meanY(ids, placed) {
+  if (ids.length === 0) return Number.POSITIVE_INFINITY;
+  return ids.reduce((sum, id) => sum + mustGet(placed, id, "position").y, 0) / ids.length;
+}
+function placementOrder(levels) {
+  const anchor = levels.reduce((best, level) => Math.abs(level) < Math.abs(best) ? level : best);
+  const outward = (side) => side.map((level, index) => [level, side[index - 1] ?? anchor]);
+  return [
+    [anchor, void 0],
+    ...outward(levels.filter((level) => level > anchor)),
+    ...outward(levels.filter((level) => level < anchor).reverse())
+  ];
+}
+function placeColumn(level, references, ctx, into) {
+  const runs = orderColumn(
+    mustGet(into.order, level, "column"),
+    ctx.groupRank,
+    (node) => meanY(
+      mustGet(ctx.neighbours, node.id, "neighbours").filter(
+        (id) => references.includes(mustGet(ctx.levelOf, id, "level"))
+      ),
+      into.placed
+    )
+  );
+  into.order.set(
+    level,
+    runs.flatMap((run) => run.nodes)
+  );
+  into.boxes.set(level, stackColumn(runs, ctx.origin(level), ctx.m, into.placed));
+}
+function countCrossings(ctx, placed) {
+  const spans = /* @__PURE__ */ new Map();
+  for (const edge of ctx.edges) {
+    const levels = [mustGet(ctx.levelOf, edge.from, "level"), mustGet(ctx.levelOf, edge.to, "level")];
+    const [lower, upper] = levels[0] < levels[1] ? [edge.from, edge.to] : [edge.to, edge.from];
+    const index = ctx.levels.indexOf(Math.min(...levels));
+    if (levels[0] === levels[1] || ctx.levels[index + 1] !== Math.max(...levels)) continue;
+    const span = [mustGet(placed, lower, "position").y, mustGet(placed, upper, "position").y];
+    spans.set(index, [...spans.get(index) ?? [], span]);
+  }
+  let crossings = 0;
+  for (const gap of spans.values()) {
+    gap.forEach((a, index) => {
+      crossings += gap.slice(index + 1).filter((b) => (a[0] - b[0]) * (a[1] - b[1]) < 0).length;
+    });
+  }
+  return crossings;
+}
+function sweep(from, sequence, ctx) {
+  const next = { order: new Map(from.order), placed: new Map(from.placed), boxes: new Map(from.boxes) };
+  for (const level of sequence) {
+    const index = ctx.levels.indexOf(level);
+    const adjacent = [ctx.levels[index - 1], ctx.levels[index + 1]].filter((other) => other !== void 0);
+    placeColumn(level, adjacent, ctx, next);
+  }
+  return next;
+}
+function arrange(columns, ctx) {
+  let current = { order: new Map(columns), placed: /* @__PURE__ */ new Map(), boxes: /* @__PURE__ */ new Map() };
+  for (const [level, reference] of placementOrder(ctx.levels)) {
+    placeColumn(level, reference === void 0 ? [] : [reference], ctx, current);
+  }
+  let best = current;
+  let fewest = countCrossings(ctx, best.placed);
+  for (let pass = 0; pass < ctx.m.sweeps && fewest > 0; pass++) {
+    current = sweep(current, pass % 2 === 0 ? [...ctx.levels].reverse() : ctx.levels, ctx);
+    const crossings = countCrossings(ctx, current.placed);
+    if (crossings < fewest) {
+      best = current;
+      fewest = crossings;
+    }
+  }
+  return best;
+}
+function columnsLayout(nodes, edges, options = {}) {
+  const m = columnMetrics(options);
+  const { columns, groupRank } = indexColumns(nodes);
+  const neighbours = indexNeighbours(nodes, edges);
+  const levels = [...columns.keys()].sort((a, b) => a - b);
+  if (levels.length === 0) {
+    return { width: 2 * m.padding, height: 2 * m.padding, positions: {}, groups: [] };
+  }
+  const minLevel = Math.min(...levels);
+  const tallest = Math.max(...[...columns.values()].map((column) => columnHeight(column, m)));
+  const inset = m.padding + (nodes.some((node) => node.group !== void 0) ? m.groupPadding : 0);
+  const { placed, boxes } = arrange(columns, {
+    m,
+    levels,
+    levelOf: new Map(nodes.map((node) => [node.id, node.level])),
+    groupRank,
+    neighbours,
+    edges,
+    origin: (level) => ({
+      x: inset + m.nodeWidth / 2 + (level - minLevel) * (m.nodeWidth + m.columnGap),
+      top: m.padding + (tallest - columnHeight(mustGet(columns, level, "column"), m)) / 2,
+      level
+    })
+  });
+  const room = loopOverhang(edges, Object.fromEntries(placed), m);
+  const span = (Math.max(...levels) - minLevel) * (m.nodeWidth + m.columnGap) + m.nodeWidth;
+  return {
+    width: room.left + 2 * inset + span + room.right,
+    height: tallest + 2 * m.padding,
+    positions: Object.fromEntries([...placed].map(([id, { x, y }]) => [id, { x: x + room.left, y }])),
+    groups: [...boxes.values()].flat().map((box) => ({ ...box, x: box.x + room.left })).sort((a, b) => a.level - b.level || a.y - b.y)
+  };
+}
+export {
+  columnsLayout
+};
+//# sourceMappingURL=graph-columns-layout.js.map

package/dist/data/graph-columns-layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-columns-layout.js","sources":["../../src/data/graph-columns-layout.ts"],"sourcesContent":["// Level-column layout for GraphDiagram: pure math, no React. Split from\n// graph-layout.ts, which owns the shared types and `ringLayout`.\n\nimport { loopOverhang } from \"./graph-edge-routing\";\nimport type { GraphLayoutEdge, GraphLayoutNode, GraphLayoutPosition, GraphLayoutResult } from \"./graph-layout\";\n\nexport interface ColumnsLayoutNode extends GraphLayoutNode {\n  /** Column of the node. May be negative: the lowest level is the first column. */\n  level: number;\n  /** Nodes sharing a group stay contiguous within their column and are boxed together. */\n  group?: string;\n}\n\nexport interface ColumnsLayoutOptions {\n  /** Node bounding-box width in px. Defaults to 168. */\n  nodeWidth?: number;\n  /** Node bounding-box height in px. Defaults to 60. */\n  nodeHeight?: number;\n  /** Horizontal gap between the node boxes of adjacent columns in px. Defaults to 96. */\n  columnGap?: number;\n  /** Vertical gap between stacked nodes, and between group rectangles, in px. Defaults to 20. */\n  rowGap?: number;\n  /** Space between a group's nodes and its rectangle in px. Defaults to 12. */\n  groupPadding?: number;\n  /** Space reserved around the columns before the viewport edge. Defaults to 24. */\n  padding?: number;\n  /**\n   * Re-ordering passes over all columns after the first placement, alternating direction; a pass\n   * is kept only if it leaves fewer crossings. Defaults to 4. 0 keeps the first placement.\n   */\n  sweeps?: number;\n}\n\nexport interface GraphLayoutGroupBox {\n  /** `${level}:${group}` — a group spanning several columns gets one rectangle per column. */\n  id: string;\n  group: string;\n  level: number;\n  /** Top-left corner, in the same coordinate space as the layout's `width`/`height`. */\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\nexport interface ColumnsLayoutResult extends GraphLayoutResult {\n  groups: GraphLayoutGroupBox[];\n}\n\ntype ColumnMetrics = Required<ColumnsLayoutOptions>;\n\ninterface GroupRun {\n  group: string | undefined;\n  nodes: ColumnsLayoutNode[];\n}\n\n/** One ordering of every column, stacked: the node centres and group rectangles it gives. */\ninterface Arrangement {\n  order: Map<number, ColumnsLayoutNode[]>;\n  placed: Map<string, GraphLayoutPosition>;\n  boxes: Map<number, GraphLayoutGroupBox[]>;\n}\n\n/** What stays fixed while columns are re-ordered. */\ninterface ColumnsContext {\n  m: ColumnMetrics;\n  levels: number[];\n  levelOf: Map<string, number>;\n  groupRank: Map<string | undefined, number>;\n  neighbours: Map<string, string[]>;\n  edges: readonly GraphLayoutEdge[];\n  /** Centre x and top y of a level's column. */\n  origin: (level: number) => { x: number; top: number; level: number };\n}\n\nconst DEFAULT_NODE_WIDTH = 168;\nconst DEFAULT_NODE_HEIGHT = 60;\nconst DEFAULT_COLUMN_GAP = 96;\nconst DEFAULT_ROW_GAP = 20;\nconst DEFAULT_GROUP_PADDING = 12;\nconst DEFAULT_PADDING = 24;\nconst DEFAULT_SWEEPS = 4;\n\nfunction mustGet<K, V>(map: ReadonlyMap<K, V>, key: K, what: string): V {\n  const value = map.get(key);\n  if (value === undefined) {\n    throw new Error(`columnsLayout: no ${what} for \"${String(key)}\"`);\n  }\n  return value;\n}\n\nfunction columnMetrics(options: ColumnsLayoutOptions): ColumnMetrics {\n  return {\n    nodeWidth: options.nodeWidth ?? DEFAULT_NODE_WIDTH,\n    nodeHeight: options.nodeHeight ?? DEFAULT_NODE_HEIGHT,\n    columnGap: options.columnGap ?? DEFAULT_COLUMN_GAP,\n    rowGap: options.rowGap ?? DEFAULT_ROW_GAP,\n    groupPadding: options.groupPadding ?? DEFAULT_GROUP_PADDING,\n    padding: options.padding ?? DEFAULT_PADDING,\n    sweeps: options.sweeps ?? DEFAULT_SWEEPS,\n  };\n}\n\nfunction indexColumns(nodes: readonly ColumnsLayoutNode[]) {\n  const columns = new Map<number, ColumnsLayoutNode[]>();\n  const groupRank = new Map<string | undefined, number>();\n  for (const node of nodes) {\n    if (!Number.isFinite(node.level)) {\n      throw new Error(`columnsLayout: node \"${node.id}\" has no finite level (got ${node.level})`);\n    }\n    if (!groupRank.has(node.group)) groupRank.set(node.group, groupRank.size);\n    const column = columns.get(node.level);\n    if (column) {\n      column.push(node);\n    } else {\n      columns.set(node.level, [node]);\n    }\n  }\n  return { columns, groupRank };\n}\n\nfunction indexNeighbours(\n  nodes: readonly ColumnsLayoutNode[],\n  edges: readonly GraphLayoutEdge[],\n): Map<string, string[]> {\n  const neighbours = new Map<string, string[]>(nodes.map((node) => [node.id, []]));\n  for (const edge of edges) {\n    const from = neighbours.get(edge.from);\n    const to = neighbours.get(edge.to);\n    if (!from || !to) {\n      const missing = from ? edge.to : edge.from;\n      throw new Error(`columnsLayout: edge \"${edge.id}\" references unknown node \"${missing}\"`);\n    }\n    from.push(edge.to);\n    to.push(edge.from);\n  }\n  return neighbours;\n}\n\nfunction columnHeight(column: readonly ColumnsLayoutNode[], m: ColumnMetrics): number {\n  const groups = new Set(column.map((node) => node.group));\n  groups.delete(undefined);\n  return column.length * m.nodeHeight + (column.length - 1) * m.rowGap + 2 * m.groupPadding * groups.size;\n}\n\n/** Groups in order of first appearance; within a group by ascending weight, the column's order on ties. */\nfunction orderColumn(\n  column: readonly ColumnsLayoutNode[],\n  groupRank: ReadonlyMap<string | undefined, number>,\n  weight: (node: ColumnsLayoutNode) => number,\n): GroupRun[] {\n  const runs = new Map<number, { node: ColumnsLayoutNode; index: number; weight: number }[]>();\n  column.forEach((node, index) => {\n    const rank = mustGet(groupRank, node.group, \"group rank\");\n    const entry = { node, index, weight: weight(node) };\n    const run = runs.get(rank);\n    if (run) {\n      run.push(entry);\n    } else {\n      runs.set(rank, [entry]);\n    }\n  });\n  return [...runs.entries()]\n    .sort(([a], [b]) => a - b)\n    .map(([, run]) => {\n      // Infinity - Infinity is NaN, which falls through to the column-order tiebreak.\n      const nodes = run.sort((a, b) => a.weight - b.weight || a.index - b.index).map((entry) => entry.node);\n      return { group: nodes[0]?.group, nodes };\n    });\n}\n\nfunction stackColumn(\n  runs: readonly GroupRun[],\n  origin: { x: number; top: number; level: number },\n  m: ColumnMetrics,\n  placed: Map<string, GraphLayoutPosition>,\n): GraphLayoutGroupBox[] {\n  const boxes: GraphLayoutGroupBox[] = [];\n  let cursor = origin.top;\n  for (const { group, nodes } of runs) {\n    const pad = group === undefined ? 0 : m.groupPadding;\n    const height = nodes.length * m.nodeHeight + (nodes.length - 1) * m.rowGap + 2 * pad;\n    nodes.forEach((node, index) => {\n      const top = cursor + pad + index * (m.nodeHeight + m.rowGap);\n      placed.set(node.id, { x: origin.x, y: top + m.nodeHeight / 2 });\n    });\n    if (group !== undefined) {\n      boxes.push({\n        id: `${origin.level}:${group}`,\n        group,\n        level: origin.level,\n        x: origin.x - m.nodeWidth / 2 - pad,\n        y: cursor,\n        width: m.nodeWidth + 2 * pad,\n        height,\n      });\n    }\n    cursor += height + m.rowGap;\n  }\n  return boxes;\n}\n\nfunction meanY(ids: readonly string[], placed: ReadonlyMap<string, GraphLayoutPosition>): number {\n  if (ids.length === 0) return Number.POSITIVE_INFINITY;\n  return ids.reduce((sum, id) => sum + mustGet(placed, id, \"position\").y, 0) / ids.length;\n}\n\n/**\n * Levels in the order they are first laid out — the one nearest 0, then\n * outward on each side — each paired with the already-placed adjacent level\n * its nodes are ordered against.\n */\nfunction placementOrder(levels: readonly number[]): [level: number, reference: number | undefined][] {\n  const anchor = levels.reduce((best, level) => (Math.abs(level) < Math.abs(best) ? level : best));\n  const outward = (side: readonly number[]) =>\n    side.map((level, index): [number, number] => [level, side[index - 1] ?? anchor]);\n  return [\n    [anchor, undefined],\n    ...outward(levels.filter((level) => level > anchor)),\n    ...outward(levels.filter((level) => level < anchor).reverse()),\n  ];\n}\n\n/** Orders one column by the mean y of its nodes' neighbours in the `references` levels, and stacks it. */\nfunction placeColumn(level: number, references: readonly number[], ctx: ColumnsContext, into: Arrangement): void {\n  const runs = orderColumn(mustGet(into.order, level, \"column\"), ctx.groupRank, (node) =>\n    meanY(\n      mustGet(ctx.neighbours, node.id, \"neighbours\").filter((id) =>\n        references.includes(mustGet(ctx.levelOf, id, \"level\")),\n      ),\n      into.placed,\n    ),\n  );\n  into.order.set(\n    level,\n    runs.flatMap((run) => run.nodes),\n  );\n  into.boxes.set(level, stackColumn(runs, ctx.origin(level), ctx.m, into.placed));\n}\n\n/** Pairs of edges between adjacent columns that cross, taking each edge as a straight line. */\nfunction countCrossings(ctx: ColumnsContext, placed: ReadonlyMap<string, GraphLayoutPosition>): number {\n  const spans = new Map<number, [lower: number, upper: number][]>();\n  for (const edge of ctx.edges) {\n    const levels = [mustGet(ctx.levelOf, edge.from, \"level\"), mustGet(ctx.levelOf, edge.to, \"level\")] as const;\n    const [lower, upper] = levels[0] < levels[1] ? [edge.from, edge.to] : [edge.to, edge.from];\n    const index = ctx.levels.indexOf(Math.min(...levels));\n    if (levels[0] === levels[1] || ctx.levels[index + 1] !== Math.max(...levels)) continue;\n    const span: [number, number] = [mustGet(placed, lower, \"position\").y, mustGet(placed, upper, \"position\").y];\n    spans.set(index, [...(spans.get(index) ?? []), span]);\n  }\n  let crossings = 0;\n  for (const gap of spans.values()) {\n    gap.forEach((a, index) => {\n      crossings += gap.slice(index + 1).filter((b) => (a[0] - b[0]) * (a[1] - b[1]) < 0).length;\n    });\n  }\n  return crossings;\n}\n\n/** A copy of `from` with every column re-ordered against both its neighbours, in the order given. */\nfunction sweep(from: Arrangement, sequence: readonly number[], ctx: ColumnsContext): Arrangement {\n  const next: Arrangement = { order: new Map(from.order), placed: new Map(from.placed), boxes: new Map(from.boxes) };\n  for (const level of sequence) {\n    const index = ctx.levels.indexOf(level);\n    const adjacent = [ctx.levels[index - 1], ctx.levels[index + 1]].filter((other): other is number => other !== undefined);\n    placeColumn(level, adjacent, ctx, next);\n  }\n  return next;\n}\n\n/**\n * Orders the columns. The first pass places the level nearest 0 and works\n * outward, ordering each column against the one just placed. Then up to\n * `sweeps` passes re-order every column against both its neighbours, inward\n * then outward, and the arrangement with the fewest crossings is kept: the\n * first pass's unless a later one strictly beats it.\n */\nfunction arrange(columns: ReadonlyMap<number, ColumnsLayoutNode[]>, ctx: ColumnsContext): Arrangement {\n  let current: Arrangement = { order: new Map(columns), placed: new Map(), boxes: new Map() };\n  for (const [level, reference] of placementOrder(ctx.levels)) {\n    placeColumn(level, reference === undefined ? [] : [reference], ctx, current);\n  }\n  let best = current;\n  let fewest = countCrossings(ctx, best.placed);\n  for (let pass = 0; pass < ctx.m.sweeps && fewest > 0; pass++) {\n    current = sweep(current, pass % 2 === 0 ? [...ctx.levels].reverse() : ctx.levels, ctx);\n    const crossings = countCrossings(ctx, current.placed);\n    if (crossings < fewest) {\n      best = current;\n      fewest = crossings;\n    }\n  }\n  return best;\n}\n\n/**\n * Places nodes in left-to-right columns by `level` (the lowest level first),\n * stacking each column top to bottom and centring it against the tallest one.\n *\n * Within a column, nodes of one group are contiguous, groups appearing in the\n * order they first occur in `nodes`. Inside a group nodes are ordered by the\n * mean y of their neighbours in the adjacent columns, so edges between columns\n * cross less (see `arrange`); nodes with no neighbour there go last, and ties\n * keep input order.\n *\n * Returns node centres plus one rectangle per (column, group). Extra width is\n * reserved on each side for the loops `routeEdges` draws outside the first and\n * last columns.\n */\nexport function columnsLayout(\n  nodes: readonly ColumnsLayoutNode[],\n  edges: readonly GraphLayoutEdge[],\n  options: ColumnsLayoutOptions = {},\n): ColumnsLayoutResult {\n  const m = columnMetrics(options);\n  const { columns, groupRank } = indexColumns(nodes);\n  const neighbours = indexNeighbours(nodes, edges);\n  const levels = [...columns.keys()].sort((a, b) => a - b);\n  if (levels.length === 0) {\n    return { width: 2 * m.padding, height: 2 * m.padding, positions: {}, groups: [] };\n  }\n\n  const minLevel = Math.min(...levels);\n  const tallest = Math.max(...[...columns.values()].map((column) => columnHeight(column, m)));\n  const inset = m.padding + (nodes.some((node) => node.group !== undefined) ? m.groupPadding : 0);\n  const { placed, boxes } = arrange(columns, {\n    m,\n    levels,\n    levelOf: new Map(nodes.map((node) => [node.id, node.level])),\n    groupRank,\n    neighbours,\n    edges,\n    origin: (level) => ({\n      x: inset + m.nodeWidth / 2 + (level - minLevel) * (m.nodeWidth + m.columnGap),\n      top: m.padding + (tallest - columnHeight(mustGet(columns, level, \"column\"), m)) / 2,\n      level,\n    }),\n  });\n\n  const room = loopOverhang(edges, Object.fromEntries(placed), m);\n  const span = (Math.max(...levels) - minLevel) * (m.nodeWidth + m.columnGap) + m.nodeWidth;\n  return {\n    width: room.left + 2 * inset + span + room.right,\n    height: tallest + 2 * m.padding,\n    positions: Object.fromEntries([...placed].map(([id, { x, y }]) => [id, { x: x + room.left, y }])),\n    groups: [...boxes.values()]\n      .flat()\n      .map((box) => ({ ...box, x: box.x + room.left }))\n      .sort((a, b) => a.level - b.level || a.y - b.y),\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/data/graph-diagram-model.cjs

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DENSE_EDGE_COUNT = 32;
+function edgeFocusOn(mode, edgeCount) {
+  return mode === "on" || mode === "auto" && edgeCount > DENSE_EDGE_COUNT;
+}
+function focusedEdgeIds(edges, focus) {
+  return new Set(
+    edges.filter((edge) => focus.edges.includes(edge.id) || focus.nodes.includes(edge.from) || focus.nodes.includes(edge.to)).map((edge) => edge.id)
+  );
+}
+const TONE_TEXT_CLASS = {
+  neutral: "text-muted-foreground",
+  success: "text-emerald-600 dark:text-emerald-400",
+  danger: "text-red-600 dark:text-red-400",
+  warning: "text-amber-600 dark:text-amber-400",
+  info: "text-sky-600 dark:text-sky-400"
+};
+const TONE_NODE_CLASS = {
+  neutral: "border-border bg-card text-foreground",
+  success: "border-emerald-500/50 bg-emerald-500/10 text-foreground",
+  danger: "border-red-500/50 bg-red-500/10 text-foreground",
+  warning: "border-amber-500/50 bg-amber-500/10 text-foreground",
+  info: "border-sky-500/50 bg-sky-500/10 text-foreground"
+};
+function nodeName(node) {
+  if (node.ariaLabel !== void 0) return node.ariaLabel;
+  return typeof node.label === "string" ? node.label : node.id;
+}
+function edgeName(edge, names) {
+  const ends = `${requireEntry(names, edge.from, "node name")} to ${requireEntry(names, edge.to, "node name")}`;
+  const pill = [edge.iconLabel, edge.label].filter(Boolean).join(" ");
+  return pill === "" ? ends : `${ends}: ${pill}`;
+}
+const LABEL_CHAR_WIDTH = 5.4;
+const LABEL_CHROME = 14;
+const LABEL_ICON_SIZE = 14;
+const LABEL_ICON_GAP = 4;
+function edgeLabelWidth(edge) {
+  var _a;
+  const icon = edge.icon == null ? 0 : LABEL_ICON_SIZE + (edge.label ? LABEL_ICON_GAP : 0);
+  return (((_a = edge.label) == null ? void 0 : _a.length) ?? 0) * LABEL_CHAR_WIDTH + icon + LABEL_CHROME;
+}
+function requireEntry(entries, id, what) {
+  const entry = entries[id];
+  if (entry === void 0) {
+    throw new Error(`GraphDiagram: no ${what} computed for "${id}"`);
+  }
+  return entry;
+}
+function hoverHandlers(id, onHover) {
+  const enter = () => onHover(id);
+  const leave = () => onHover(void 0);
+  return { onMouseEnter: enter, onMouseLeave: leave, onFocus: enter, onBlur: leave };
+}
+function activateOnKey(event, activate) {
+  if (event.key === "Enter" || event.key === " ") {
+    event.preventDefault();
+    activate();
+  }
+}
+exports.DENSE_EDGE_COUNT = DENSE_EDGE_COUNT;
+exports.TONE_NODE_CLASS = TONE_NODE_CLASS;
+exports.TONE_TEXT_CLASS = TONE_TEXT_CLASS;
+exports.activateOnKey = activateOnKey;
+exports.edgeFocusOn = edgeFocusOn;
+exports.edgeLabelWidth = edgeLabelWidth;
+exports.edgeName = edgeName;
+exports.focusedEdgeIds = focusedEdgeIds;
+exports.hoverHandlers = hoverHandlers;
+exports.nodeName = nodeName;
+exports.requireEntry = requireEntry;
+//# sourceMappingURL=graph-diagram-model.cjs.map