@yalehwang/plantuml-js 0.2.2 → 0.3.0

package/dist/transform.js

@@ -9,6 +9,11 @@
  * input and produces the same output for the same input, so a transformed
  * render stays byte-for-byte reproducible.
  */
+import { relationSemantics } from './foundation/relation-semantics.js';
+/** Entity count above which inter-package edges aggregate into corridors by default. */
+export const INTER_PACKAGE_AGGREGATE_ENTITY_THRESHOLD = 150;
+/** Stub count above which a single-package view groups stubs by name prefix. */
+export const DEFAULT_STUB_GROUP_THRESHOLD = 8;
 const ROOT = '__root__';
 function cloneModel(model) {
     return {
@@ -24,23 +29,89 @@ function cloneModel(model) {
  * summarization, then cycle marking on the final edge set.
  */
 export function transformModel(model, options = {}) {
-    const { aggregate = true, transitiveReduction = false, hubThreshold, cycles = false } = options;
+    return transformModelDetailed(model, options).model;
+}
+/** [[transformModel]] plus the number of edges the transitive reduction hid. */
+export function transformModelDetailed(model, options = {}) {
+    const { aggregate = true, transitiveReduction = false, hubThreshold, cycles = false, interPackage = 'raw' } = options;
     let out = cloneModel(model);
+    out = summarizeExternals(out, EXTERNAL_SUMMARY_MIN_IN_EDGES);
     if (aggregate)
         out = aggregateRelations(out);
-    if (transitiveReduction)
+    let hiddenTransitive = 0;
+    if (transitiveReduction) {
+        const before = out.relations.length;
         out = transitiveReduce(out);
+        hiddenTransitive = before - out.relations.length;
+    }
     if (hubThreshold !== undefined)
         out = summarizeHubs(out, hubThreshold);
+    if (interPackage === 'aggregate')
+        out = aggregateInterPackage(out);
     if (cycles)
         out = markCycles(out);
-    return out;
+    return { model: groupExternals(out), hiddenTransitive };
+}
+/** Edge count ÷ node count above which `edgeReduction: 'auto'` reduces a pure dependency graph. */
+export const AUTO_REDUCTION_EDGE_NODE_RATIO = 3;
+/**
+ * Whether `edgeReduction: 'auto'` applies: every relation is bundlable
+ * (dependency/association) and there are more than
+ * [[AUTO_REDUCTION_EDGE_NODE_RATIO]] times as many edges as nodes.
+ */
+export function shouldAutoReduce(model) {
+    if (model.relations.length === 0)
+        return false;
+    if (!model.relations.every((r) => relationSemantics(r.type).isBundlable()))
+        return false;
+    const nodes = model.entities.length;
+    const distinct = new Set(model.relations.map((r) => `${r.source}\u0000${r.target}`)).size;
+    return distinct > AUTO_REDUCTION_EDGE_NODE_RATIO * nodes;
+}
+/** Incoming edges at which an external type's edges collapse into a count badge. */
+export const EXTERNAL_SUMMARY_MIN_IN_EDGES = 3;
+/** Id of the synthetic package that gathers implicit/external types. */
+export const EXTERNAL_PACKAGE_ID = '__external__';
+/**
+ * Implicit/external types (`Error`, `EventEmitter`, …) receive many parallel
+ * edges that would fly across the whole canvas. Once one has `minEdges` or more
+ * incoming relations they are dropped and replaced by a `usageCount` badge that
+ * carries the original incoming-edge count.
+ */
+export function summarizeExternals(model, minEdges) {
+    const incoming = new Map();
+    for (const r of model.relations) {
+        const e = model.entities.find((x) => x.id === r.target);
+        if (e?.external)
+            incoming.set(r.target, (incoming.get(r.target) ?? 0) + (r.weight ?? 1));
+    }
+    const summarized = new Set([...incoming].filter(([, n]) => n >= minEdges).map(([id]) => id));
+    if (summarized.size === 0)
+        return model;
+    return {
+        ...model,
+        entities: model.entities.map((e) => summarized.has(e.id) ? { ...e, usageCount: incoming.get(e.id) } : e),
+        relations: model.relations.filter((r) => !summarized.has(r.target)),
+    };
+}
+/** Gather top-level external entities into one synthetic External package. */
+export function groupExternals(model) {
+    const externals = model.entities.filter((e) => e.external && e.packageId === undefined);
+    if (externals.length < 2 || model.packages.some((p) => p.id === EXTERNAL_PACKAGE_ID)) {
+        return model;
+    }
+    const ids = new Set(externals.map((e) => e.id));
+    return {
+        ...model,
+        entities: model.entities.map((e) => (ids.has(e.id) ? { ...e, packageId: EXTERNAL_PACKAGE_ID } : e)),
+        packages: [...model.packages, { id: EXTERNAL_PACKAGE_ID, name: 'External' }],
+    };
 }
 /** Merge relations sharing (source, target) into one edge with `weight`. */
 export function aggregateRelations(model) {
     const byKey = new Map();
     for (const relation of model.relations) {
-        const key = `${relation.source}\u0000${relation.target}`;
+        const key = `${relation.source}\u0000${relation.target}\u0000${relation.sourcePackageId ?? ''}\u0000${relation.targetPackageId ?? ''}`;
         const existing = byKey.get(key);
         if (existing) {
             existing.weight = (existing.weight ?? 1) + 1;
@@ -51,6 +122,89 @@ export function aggregateRelations(model) {
     }
     return { ...model, relations: [...byKey.values()] };
 }
+/**
+ * Fold every relation between two different packages into one corridor edge
+ * per ordered package pair: `weight` = number of originals, `descriptions`
+ * keeps each original, and the endpoints are the entities carrying most of the
+ * traffic with `sourcePackageId`/`targetPackageId` set so the layout clips the
+ * edge to the frame boundaries. Intra-package edges and edges touching
+ * package-less entities, or between nested packages, are left as they are.
+ */
+export function aggregateInterPackage(model) {
+    const pkgOf = new Map(model.entities.map((e) => [e.id, e.packageId]));
+    const parent = new Map(model.packages.map((p) => [p.id, p.parentId]));
+    const nested = (a, b) => {
+        for (const [x, y] of [[a, b], [b, a]]) {
+            for (let p = parent.get(x); p !== undefined; p = parent.get(p))
+                if (p === y)
+                    return true;
+        }
+        return false;
+    };
+    const groups = new Map();
+    const relations = [];
+    for (const rel of model.relations) {
+        const a = pkgOf.get(rel.source);
+        const b = pkgOf.get(rel.target);
+        if (!a || !b || a === b || nested(a, b) || rel.sourcePackageId || rel.targetPackageId) {
+            relations.push(rel);
+            continue;
+        }
+        const key = `${a}\u0000${b}`;
+        let g = groups.get(key);
+        if (!g) {
+            g = { src: a, dst: b, items: [], srcCount: new Map(), dstCount: new Map(), at: relations.length };
+            groups.set(key, g);
+            relations.push(g);
+        }
+        g.items.push(rel);
+        g.srcCount.set(rel.source, (g.srcCount.get(rel.source) ?? 0) + 1);
+        g.dstCount.set(rel.target, (g.dstCount.get(rel.target) ?? 0) + 1);
+    }
+    const top = (m) => {
+        let best = '';
+        let n = -1;
+        for (const [k, v] of m)
+            if (v > n) {
+                best = k;
+                n = v;
+            }
+        return best;
+    };
+    const out = relations.map((r) => {
+        if (!('items' in r))
+            return r;
+        const types = new Set(r.items.map((i) => i.type));
+        const only = r.items.length === 1 ? r.items[0].type : [...types][0];
+        const type = types.size === 1 && relationSemantics(only).isBundlable() ? only : 'dependency';
+        return {
+            source: top(r.srcCount),
+            target: top(r.dstCount),
+            type,
+            weight: r.items.reduce((sum, i) => sum + (i.weight ?? 1), 0),
+            feedback: r.items.every((i) => i.feedback) || undefined,
+            sourcePackageId: r.src,
+            targetPackageId: r.dst,
+            descriptions: r.items.map((i) => `${i.source} ${ARROWS[i.type]} ${i.target}${i.label ? ` : ${i.label}` : ''}`),
+        };
+    });
+    return { ...model, relations: out.map(dropUndefined) };
+}
+const ARROWS = {
+    inheritance: '--|>',
+    implementation: '..|>',
+    dependency: '..>',
+    association: '-->',
+    aggregation: 'o--',
+    composition: '*--',
+};
+function dropUndefined(r) {
+    const copy = { ...r };
+    for (const k of Object.keys(copy))
+        if (copy[k] === undefined)
+            delete copy[k];
+    return copy;
+}
 /**
  * Remove a relation A→B when A still reaches B through another path (an edge
  * derivable by transitivity). Only the redundant direct edge is dropped; the
@@ -58,37 +212,52 @@ export function aggregateRelations(model) {
  */
 export function transitiveReduce(model) {
     const targets = new Map();
-    for (const relation of model.relations) {
-        const list = targets.get(relation.source);
-        if (list)
-            list.push(relation.target);
-        else
-            targets.set(relation.source, [relation.target]);
-    }
-    const reachable = (start, goal, skipTarget) => {
-        const seen = new Set();
-        const queue = [start];
-        while (queue.length > 0) {
-            const u = queue.shift();
-            for (const v of targets.get(u) ?? []) {
-                if (u === start && v === skipTarget)
-                    continue; // ignore the direct edge under test
+    const addEdge = (u, v) => {
+        const m = targets.get(u) ?? new Map();
+        m.set(v, (m.get(v) ?? 0) + 1);
+        targets.set(u, m);
+    };
+    for (const relation of model.relations)
+        addEdge(relation.source, relation.target);
+    const reachable = (start, goal) => {
+        const seen = new Set([start]);
+        const stack = [start];
+        while (stack.length > 0) {
+            const u = stack.pop();
+            for (const v of targets.get(u)?.keys() ?? []) {
                 if (v === goal)
                     return true;
                 if (!seen.has(v)) {
                     seen.add(v);
-                    queue.push(v);
+                    stack.push(v);
                 }
             }
         }
         return false;
     };
-    const relations = model.relations.filter((relation) => {
-        // A self-loop is its own shortest witness; keep it. A single-hop edge with
-        // no alternate path is necessary; keep it.
-        return !reachable(relation.source, relation.target, relation.target);
+    // Greedy in authored order: an edge is dropped when its end points stay
+    // connected through the edges still present, so reachability is preserved
+    // exactly (also inside cycles, where dropping every "redundant" edge at once
+    // would disconnect the cycle). A self-loop is its own witness and is kept.
+    const removed = new Set();
+    model.relations.forEach((relation, i) => {
+        if (relation.source === relation.target)
+            return;
+        const out = targets.get(relation.source);
+        const count = out.get(relation.target);
+        if (count > 1) {
+            // A parallel duplicate of the same pair is always redundant.
+            out.set(relation.target, count - 1);
+            removed.add(i);
+            return;
+        }
+        out.delete(relation.target);
+        if (reachable(relation.source, relation.target))
+            removed.add(i);
+        else
+            out.set(relation.target, 1);
     });
-    return { ...model, relations };
+    return { ...model, relations: model.relations.filter((_, i) => !removed.has(i)) };
 }
 /**
  * Nodes with an in-degree above `threshold` have their incoming edges dropped
@@ -170,7 +339,7 @@ export function applyView(model, view) {
             }
             return overviewView(model);
         case 'package':
-            return packageView(model, view.id);
+            return packageView(model, view.id, view.stubGroupThreshold ?? DEFAULT_STUB_GROUP_THRESHOLD);
         case 'neighborhood':
             return neighborhoodView(model, view.entity, view.hops);
     }
@@ -276,7 +445,7 @@ export function groupByPathPrefix(model, depth) {
  * merged by aggregation). Entities and relations entirely outside the package
  * are dropped.
  */
-function packageView(model, id) {
+function packageView(model, id, stubGroupThreshold) {
     const pkgById = new Map(model.packages.map((p) => [p.id, p]));
     const selected = pkgById.get(id);
     if (!selected) {
@@ -332,13 +501,92 @@ function packageView(model, id) {
         const stub = stubFor(externalKey);
         relations.push(sourceIn ? { ...relation, target: stub.id } : { ...relation, source: stub.id });
     }
+    const grouped = groupStubs({ entities, relations }, stubGroupThreshold);
     return {
         diagramType: 'class',
-        entities,
-        relations,
+        entities: grouped.entities,
+        relations: grouped.relations,
         packages: [{ ...selected, parentId: undefined }],
     };
 }
+/** Name with its last word dropped (`Src Cli Utils` → `Src Cli`); a one-word name stays as is. */
+function namePrefix(name) {
+    const words = name.trim().split(/\s+/);
+    return words.length > 1 ? words.slice(0, -1).join(' ') : name;
+}
+/**
+ * Past `threshold` stubs, merge stubs sharing a name prefix into one group stub
+ * (`Src Cli … (×6)`), dropping trailing words until the group count fits (or nothing shortens any
+ * more). The edges to the members of a group collapse onto
+ * the group stub per (entity, direction): `weight` counts the originals and
+ * `descriptions` keeps each one for the edge's `<title>`.
+ */
+export function groupStubs(model, threshold) {
+    const stubs = model.entities.filter((e) => e.stub);
+    if (stubs.length <= threshold)
+        return model;
+    let keyOf = new Map(stubs.map((e) => [e.id, e.name]));
+    for (;;) {
+        if (new Set(keyOf.values()).size <= threshold)
+            break;
+        const next = new Map([...keyOf].map(([id, k]) => [id, namePrefix(k)]));
+        if ([...next].every(([id, k]) => k === keyOf.get(id)))
+            break;
+        keyOf = next;
+    }
+    const members = new Map();
+    for (const stub of stubs) {
+        const key = keyOf.get(stub.id);
+        const list = members.get(key);
+        if (list)
+            list.push(stub);
+        else
+            members.set(key, [stub]);
+    }
+    const groupId = new Map();
+    const entities = [];
+    for (const e of model.entities) {
+        if (!e.stub) {
+            entities.push(e);
+            continue;
+        }
+        const key = keyOf.get(e.id);
+        const list = members.get(key);
+        if (list.length === 1) {
+            groupId.set(e.id, e.id);
+            entities.push(e);
+        }
+        else if (list[0] === e) {
+            const id = `stub::group::${key}`;
+            for (const m of list)
+                groupId.set(m.id, id);
+            entities.push({ ...e, id, name: `${list.length} other ${key} packages`, groupMembers: list.map((m) => m.name) });
+        }
+    }
+    const merged = new Map();
+    const out = [];
+    const label = (r) => `${r.source} ${r.type} ${r.target}`;
+    for (const r of model.relations) {
+        const source = groupId.get(r.source) ?? r.source;
+        const target = groupId.get(r.target) ?? r.target;
+        if (source === r.source && target === r.target) {
+            out.push(r);
+            continue;
+        }
+        const key = `${source}\u0000${target}`;
+        const existing = merged.get(key);
+        if (existing) {
+            existing.weight = (existing.weight ?? 1) + (r.weight ?? 1);
+            existing.descriptions.push(...(r.descriptions ?? [label(r)]));
+        }
+        else {
+            const rel = { ...r, source, target, weight: r.weight ?? 1, descriptions: [...(r.descriptions ?? [label(r)])] };
+            merged.set(key, rel);
+            out.push(rel);
+        }
+    }
+    return { entities, relations: out };
+}
 /**
  * Expand one entity plus every entity within `hops` undirected hops, together
  * with the package frames that contain the kept entities.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yalehwang/plantuml-js",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Pure-TypeScript PlantUML class diagram renderer (MIT)",
   "type": "module",
   "license": "MIT",
@@ -34,12 +34,13 @@
     "node": ">=18"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.test.json",
     "test": "vitest run",
     "demo:build": "node scripts/build-demo.mjs",
     "release": "node scripts/release.mjs",
-    "prepublishOnly": "npm run typecheck && npm run build"
+    "prepublishOnly": "npm run typecheck && npm run build && node scripts/check-dist-clean.mjs"
   },
   "dependencies": {
     "@viz-js/viz": "^3.31.0",

package/dist/layout-metrics.d.ts

@@ -1,42 +0,0 @@
-/**
- * Layout quality metrics. Pure functions from (model, layout) to numbers, so a
- * layout strategy change can be judged by a diff in figures rather than by eye.
- *
- * Edge polylines are taken at face value: for the viz engine they are bezier
- * control points, which is a coarse but consistent approximation. Every metric
- * is deterministic — the same (model, layout) always yields the same numbers —
- * so a run can be committed as `rendered/metrics.baseline.json` and diffed
- * against a later run to prove an improvement or a regression.
- */
-import { PlantUmlModel } from './model.js';
-import { LayoutResult } from './layout.js';
-export interface LayoutMetrics {
-    /** Proper crossings between segments of two different edges. */
-    edgeCrossings: number;
-    /** Edge segments passing through the interior of an unrelated node. */
-    edgeNodeIntersections: number;
-    /** Summed polyline length of every edge, in canvas pixels. */
-    totalEdgeLength: number;
-    /** Sum of node areas divided by canvas area (0..1). */
-    areaUtilization: number;
-    /** Canvas width / height. */
-    aspectRatio: number;
-    /** Entity text lines wider than the box they are drawn in. */
-    textOverflowCount: number;
-    /** Package label tabs that overlap content or are narrower than their text. */
-    labelOverlapCount: number;
-    /**
-     * Summed length of collinear, overlapping segments from *different* edges —
-     * the orthogonal router's "parallel-line wall" is invisible to
-     * [[edgeCrossings]] (segments that merely overlap never *cross*), so this
-     * counts that hidden overlap in canvas pixels.
-     */
-    overlappingEdgeLength: number;
-    /**
-     * Incoming arrowheads stacked beyond a threshold on the same side of the
-     * same node — the "everything points at this hub" pile-up that
-     * [[edgeCrossings]] cannot see either.
-     */
-    hubArrowStack: number;
-}
-export declare function computeLayoutMetrics(model: PlantUmlModel, layout: LayoutResult): LayoutMetrics;

package/dist/layout-metrics.js

@@ -1,241 +0,0 @@
-/**
- * Layout quality metrics. Pure functions from (model, layout) to numbers, so a
- * layout strategy change can be judged by a diff in figures rather than by eye.
- *
- * Edge polylines are taken at face value: for the viz engine they are bezier
- * control points, which is a coarse but consistent approximation. Every metric
- * is deterministic — the same (model, layout) always yields the same numbers —
- * so a run can be committed as `rendered/metrics.baseline.json` and diffed
- * against a later run to prove an improvement or a regression.
- */
-import { METRICS, displayName } from './layout.js';
-import { countEdgeBoxIntersections, nodeRect } from './edge-router.js';
-import { measureTextWidth } from './text-measure.js';
-/** Package label tab geometry, kept in step with [[../render/svg]]. */
-const PACKAGE_TAB_HEIGHT = 18;
-const PACKAGE_LABEL_FONT_SIZE = 12;
-const PACKAGE_TAB_PADDING = 12;
-export function computeLayoutMetrics(model, layout) {
-    const edges = layout.edges ?? [];
-    const nodeArea = layout.nodes.reduce((sum, n) => sum + n.width * n.height, 0);
-    const canvasArea = layout.width * layout.height;
-    return {
-        edgeCrossings: countEdgeCrossings(edges.map((e) => e.points)),
-        edgeNodeIntersections: countEdgeBoxIntersections(edges, layout.nodes),
-        totalEdgeLength: edges.reduce((sum, e) => sum + polylineLength(e.points), 0),
-        areaUtilization: canvasArea > 0 ? nodeArea / canvasArea : 0,
-        aspectRatio: layout.height > 0 ? layout.width / layout.height : 0,
-        textOverflowCount: countTextOverflow(model, layout),
-        labelOverlapCount: countLabelOverlap(model, layout),
-        overlappingEdgeLength: countOverlappingEdgeLength(edges.map((e) => e.points)),
-        hubArrowStack: countHubArrowStack(edges),
-    };
-}
-function polylineLength(points) {
-    let len = 0;
-    for (let i = 0; i + 1 < points.length; i++) {
-        len += Math.hypot(points[i + 1].x - points[i].x, points[i + 1].y - points[i].y);
-    }
-    return len;
-}
-function orient(a, b, c) {
-    const v = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
-    return Math.abs(v) < 1e-9 ? 0 : v > 0 ? 1 : -1;
-}
-/** True when segments ab and cd cross at a point interior to both. */
-function segmentsCross(a, b, c, d) {
-    const o1 = orient(a, b, c);
-    const o2 = orient(a, b, d);
-    const o3 = orient(c, d, a);
-    const o4 = orient(c, d, b);
-    return o1 * o2 < 0 && o3 * o4 < 0;
-}
-function countEdgeCrossings(polylines) {
-    const segs = [];
-    polylines.forEach((pts, edge) => {
-        for (let i = 0; i + 1 < pts.length; i++) {
-            const a = pts[i];
-            const b = pts[i + 1];
-            segs.push({
-                a,
-                b,
-                edge,
-                minX: Math.min(a.x, b.x),
-                maxX: Math.max(a.x, b.x),
-                minY: Math.min(a.y, b.y),
-                maxY: Math.max(a.y, b.y),
-            });
-        }
-    });
-    segs.sort((p, q) => p.minX - q.minX);
-    let count = 0;
-    for (let i = 0; i < segs.length; i++) {
-        const s = segs[i];
-        for (let j = i + 1; j < segs.length; j++) {
-            const t = segs[j];
-            if (t.minX > s.maxX)
-                break;
-            if (t.edge === s.edge)
-                continue;
-            if (t.maxY < s.minY || t.minY > s.maxY)
-                continue;
-            if (segmentsCross(s.a, s.b, t.a, t.b))
-                count++;
-        }
-    }
-    return count;
-}
-function countTextOverflow(model, layout) {
-    const nodes = new Map(layout.nodes.map((n) => [n.id, n]));
-    let count = 0;
-    for (const entity of model.entities) {
-        const node = nodes.get(entity.id);
-        if (!node)
-            continue;
-        const lines = [displayName(entity), ...entity.members.map((m) => m.raw)];
-        for (const line of lines) {
-            const needed = measureTextWidth(line, METRICS.fontSize) + METRICS.paddingX * 2;
-            if (needed > node.width + 0.01)
-                count++;
-        }
-    }
-    return count;
-}
-function rectsOverlap(a, b) {
-    return (a.x < b.x + b.width &&
-        b.x < a.x + a.width &&
-        a.y < b.y + b.height &&
-        b.y < a.y + a.height);
-}
-/**
- * A package's label tab is drawn at its top-left corner. It is counted when it
- * overlaps an entity or sub-package frame inside the package, or when the tab
- * is narrower than the label text it has to hold.
- */
-function countLabelOverlap(model, layout) {
-    const frames = new Map((layout.packages ?? []).map((p) => [p.id, p]));
-    const nodes = new Map(layout.nodes.map((n) => [n.id, n]));
-    let count = 0;
-    for (const pkg of model.packages) {
-        const frame = frames.get(pkg.id);
-        if (!frame)
-            continue;
-        const textWidth = measureTextWidth(pkg.name, PACKAGE_LABEL_FONT_SIZE);
-        const wanted = textWidth + PACKAGE_TAB_PADDING;
-        const tab = {
-            x: frame.x,
-            y: frame.y,
-            width: Math.min(frame.width, Math.max(24, wanted)),
-            height: PACKAGE_TAB_HEIGHT,
-        };
-        let bad = textWidth + 6 > tab.width + 0.01;
-        for (const entity of model.entities) {
-            if (bad)
-                break;
-            if (entity.packageId !== pkg.id)
-                continue;
-            const node = nodes.get(entity.id);
-            if (node && rectsOverlap(tab, nodeRect(node)))
-                bad = true;
-        }
-        for (const child of model.packages) {
-            if (bad)
-                break;
-            if (child.parentId !== pkg.id)
-                continue;
-            const childFrame = frames.get(child.id);
-            if (childFrame && rectsOverlap(tab, childFrame))
-                bad = true;
-        }
-        if (bad)
-            count++;
-    }
-    return count;
-}
-/**
- * Summed length of collinear, overlapping segments from different edges. Two
- * axis-aligned segments that lie on the same line and overlap are a
- * "parallel-line wall": they never produce a proper crossing (so
- * [[countEdgeCrossings]] misses them) yet still read as clutter. Each
- * (segment, segment) overlap is counted once, in canvas pixels.
- */
-function countOverlappingEdgeLength(polylines) {
-    const segs = [];
-    polylines.forEach((pts, edge) => {
-        for (let i = 0; i + 1 < pts.length; i++) {
-            segs.push({ a: pts[i], b: pts[i + 1], edge });
-        }
-    });
-    let total = 0;
-    for (let i = 0; i < segs.length; i++) {
-        for (let j = i + 1; j < segs.length; j++) {
-            if (segs[i].edge === segs[j].edge)
-                continue;
-            total += collinearOverlapLength(segs[i].a, segs[i].b, segs[j].a, segs[j].b);
-        }
-    }
-    return total;
-}
-/** Overlap length of two segments when collinear, else 0 (in canvas pixels). */
-function collinearOverlapLength(a, b, c, d) {
-    const ux = b.x - a.x;
-    const uy = b.y - a.y;
-    const vx = d.x - c.x;
-    const vy = d.y - c.y;
-    const lenU = Math.hypot(ux, uy);
-    const lenV = Math.hypot(vx, vy);
-    if (lenU < 1e-9 || lenV < 1e-9)
-        return 0;
-    // Parallel: the two direction vectors must be colinear.
-    if (Math.abs(ux * vy - uy * vx) > 1e-9 * lenU * lenV)
-        return 0;
-    // Colinear: `c` must lie on the line through `a`/`b` (perpendicular distance).
-    const distC = Math.abs(ux * (c.y - a.y) - uy * (c.x - a.x)) / lenU;
-    if (distC > 0.01)
-        return 0;
-    const uxN = ux / lenU;
-    const uyN = uy / lenU;
-    const proj = (p) => (p.x - a.x) * uxN + (p.y - a.y) * uyN;
-    const t0 = Math.min(proj(a), proj(b));
-    const t1 = Math.max(proj(a), proj(b));
-    const s0 = Math.min(proj(c), proj(d));
-    const s1 = Math.max(proj(c), proj(d));
-    const overlap = Math.min(t1, s1) - Math.max(t0, s0);
-    return overlap > 0 ? overlap : 0;
-}
-/**
- * Incoming arrowheads are grouped by (target node, entry side). A side that
- * receives more than [[HUB_ARROW_STACK_THRESHOLD]] arrowheads contributes its
- * excess to the total — the "everyone points at this hub from the same side"
- * pile-up, invisible to [[countEdgeCrossings]].
- */
-const HUB_ARROW_STACK_THRESHOLD = 3;
-function countHubArrowStack(edges) {
-    const groups = new Map();
-    for (const edge of edges) {
-        const pts = edge.points;
-        if (pts.length < 2)
-            continue;
-        const side = approachSide(pts[pts.length - 2], pts[pts.length - 1]);
-        if (side === undefined)
-            continue;
-        const key = `${edge.target}\u0000${side}`;
-        groups.set(key, (groups.get(key) ?? 0) + 1);
-    }
-    let total = 0;
-    for (const count of groups.values()) {
-        if (count > HUB_ARROW_STACK_THRESHOLD)
-            total += count - HUB_ARROW_STACK_THRESHOLD;
-    }
-    return total;
-}
-/** Side of the target the arrowhead enters from, derived from the last segment. */
-function approachSide(from, to) {
-    const dx = to.x - from.x;
-    const dy = to.y - from.y;
-    if (Math.abs(dx) < 1e-9 && Math.abs(dy) < 1e-9)
-        return undefined;
-    if (Math.abs(dx) >= Math.abs(dy))
-        return dx > 0 ? 'left' : 'right';
-    return dy > 0 ? 'top' : 'bottom';
-}