@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/network/GeoFreeNodeLink.js

@@ -0,0 +1,127 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { EdgeRouter } from "./EdgeRouter.js";
+import { NetworkEdge, NetworkMetric } from "./networkEnums.js";
+import { NetworkSamples } from "./NetworkSamples.js";
+import { NodeLinkNetwork } from "./NodeLinkNetwork.js";
+import { geoAzimuthalEquidistant, geoEqualEarth, geoEquirectangular, geoGraticule10, geoMercator, geoNaturalEarth1, geoPath } from "d3";
+// src/charts/network/GeoFreeNodeLink.ts
+var GeoFreeProjection = /* @__PURE__ */ function(GeoFreeProjection) {
+	GeoFreeProjection["NaturalEarth"] = "natural-earth";
+	GeoFreeProjection["Equirectangular"] = "equirectangular";
+	GeoFreeProjection["Mercator"] = "mercator";
+	GeoFreeProjection["EqualEarth"] = "equal-earth";
+	GeoFreeProjection["Azimuthal"] = "azimuthal";
+	return GeoFreeProjection;
+}({});
+/** How links travel: flat shapes, or along the great circle. */
+var GeoFreeRoute = /* @__PURE__ */ function(GeoFreeRoute) {
+	GeoFreeRoute["Geodesic"] = "geodesic";
+	GeoFreeRoute["Straight"] = "straight";
+	GeoFreeRoute["Arc"] = "arc";
+	GeoFreeRoute["Bundled"] = "bundled";
+	return GeoFreeRoute;
+}({});
+var PROJECTIONS = {
+	["natural-earth"]: geoNaturalEarth1,
+	["equirectangular"]: geoEquirectangular,
+	["mercator"]: geoMercator,
+	["equal-earth"]: geoEqualEarth,
+	["azimuthal"]: geoAzimuthalEquidistant
+};
+/** A network placed by real coordinates with no basemap: the map's shape comes from the data, not the coastline. */
+var GeoFreeNodeLink = class extends NodeLinkNetwork {
+	static meta = {
+		id: "geo-free-node-link",
+		name: "Geo-free node-link",
+		family: ChartFamily.Network,
+		dimension: Dimension.Two,
+		shape: DataShape.Graph,
+		description: "Places network nodes by longitude and latitude without a basemap, so routes alone sketch the geography.",
+		tags: [
+			"network",
+			"geographic network",
+			"routes",
+			"no basemap"
+		],
+		sample: (seed) => NetworkSamples.located(seed),
+		variants: {
+			projection: [
+				"natural-earth",
+				"equirectangular",
+				"mercator",
+				"equal-earth",
+				"azimuthal"
+			],
+			route: [
+				"geodesic",
+				"straight",
+				"arc",
+				"bundled"
+			],
+			graticule: [true, false],
+			nodeSize: [
+				NetworkMetric.Value,
+				NetworkMetric.Degree,
+				NetworkMetric.Uniform
+			]
+		}
+	};
+	projection = null;
+	defaults() {
+		return {
+			...super.defaults(),
+			lon: "lon",
+			lat: "lat",
+			projection: "natural-earth",
+			route: "geodesic",
+			graticule: true,
+			nodeSize: NetworkMetric.Value,
+			labels: 10
+		};
+	}
+	coordinate(node) {
+		return [Number(node.raw?.[this.options.lon]), Number(node.raw?.[this.options.lat])];
+	}
+	view(model) {
+		return model.subgraph(model.nodes.filter((node) => node.raw?.[this.options.lon] != null && node.raw?.[this.options.lat] != null && this.coordinate(node).every(Number.isFinite)));
+	}
+	radii(model, metric, ctx) {
+		return this.capped(super.radii(model, metric, ctx), 8);
+	}
+	place(ctx, model, radii) {
+		const pad = Math.max(...radii) + 4, { width, height } = ctx.plot;
+		const projection = PROJECTIONS[this.options.projection]();
+		const coords = model.nodes.map((node) => this.coordinate(node));
+		if (this.options.projection === "azimuthal") projection.rotate([-coords.reduce((sum, c) => sum + c[0], 0) / coords.length, -coords.reduce((sum, c) => sum + c[1], 0) / coords.length]);
+		projection.fitExtent([[pad, pad], [width - pad, height - pad]], new Set(coords.map(String)).size > 1 ? {
+			type: "MultiPoint",
+			coordinates: coords
+		} : { type: "Sphere" });
+		projection.clipExtent([[0, 0], [width, height]]);
+		this.projection = projection;
+		return model.nodes.map((node) => {
+			const [x, y] = projection(this.coordinate(node)) ?? [width / 2, height / 2];
+			return {
+				x,
+				y
+			};
+		});
+	}
+	underlay(ctx) {
+		const lines = this.options.graticule ? [geoPath(this.projection)(geoGraticule10()) ?? ""] : [];
+		const net = ctx.marks("graticule", "path", lines).attr("fill", "none").attr("stroke", ctx.theme.grid).attr("stroke-width", 1);
+		ctx.set(net, { d: (d) => d }, { d: (d) => d });
+	}
+	routeEdge(link, input) {
+		const { route } = this.options;
+		if (route === "geodesic") {
+			const line = {
+				type: "LineString",
+				coordinates: [this.coordinate(link.source), this.coordinate(link.target)]
+			};
+			return { d: geoPath(this.projection)(line) ?? "" };
+		}
+		return EdgeRouter.route(route === "arc" ? NetworkEdge.Arc : route === "bundled" ? NetworkEdge.Bundled : NetworkEdge.Straight, input);
+	}
+};
+export { GeoFreeNodeLink, GeoFreeProjection, GeoFreeRoute };

package/dist/charts/network/GraphCommunities.js

@@ -0,0 +1,101 @@
+import { NetworkCommunity } from "./networkEnums.js";
+// src/charts/network/GraphCommunities.ts
+/** Community detection. `label` returns a stable community number per node index, largest first. */
+var GraphCommunities = class {
+	static label(model, method) {
+		switch (method) {
+			case NetworkCommunity.Louvain: return this.rank(this.louvain(model));
+			case NetworkCommunity.LabelPropagation: return this.rank(this.propagate(model));
+			default: return this.rank(model.nodes.map((node) => model.groups.indexOf(node.group)));
+		}
+	}
+	/** Copy of the model whose groups are the detected communities. */
+	static apply(model, method) {
+		if (method === NetworkCommunity.Attribute) return model;
+		const labels = this.label(model, method);
+		return model.regroup((node) => `Community ${labels[node.index] + 1}`, true);
+	}
+	static rank(labels) {
+		const sizes = /* @__PURE__ */ new Map();
+		for (const label of labels) sizes.set(label, (sizes.get(label) ?? 0) + 1);
+		const order = [...sizes].sort((a, b) => b[1] - a[1] || a[0] - b[0]).map(([label]) => label);
+		return labels.map((label) => order.indexOf(label));
+	}
+	static propagate(model) {
+		const labels = model.nodes.map((node) => node.index);
+		const weights = this.weights(model);
+		for (let round = 0; round < 30; round++) {
+			let moved = false;
+			for (const node of model.nodes) {
+				const votes = /* @__PURE__ */ new Map();
+				for (const [other, weight] of weights[node.index]) votes.set(labels[other], (votes.get(labels[other]) ?? 0) + weight);
+				const best = [...votes].sort((a, b) => b[1] - a[1] || a[0] - b[0])[0];
+				if (best && best[0] !== labels[node.index]) {
+					labels[node.index] = best[0];
+					moved = true;
+				}
+			}
+			if (!moved) break;
+		}
+		return labels;
+	}
+	static weights(model) {
+		const weights = model.nodes.map(() => /* @__PURE__ */ new Map());
+		for (const { source, target, value } of model.links) {
+			weights[source.index].set(target.index, (weights[source.index].get(target.index) ?? 0) + value);
+			weights[target.index].set(source.index, (weights[target.index].get(source.index) ?? 0) + value);
+		}
+		return weights;
+	}
+	/** Louvain modularity optimisation, in visiting order, so the result is deterministic. */
+	static louvain(model) {
+		let weights = this.weights(model);
+		let members = model.nodes.map((node) => [node.index]);
+		for (let level = 0; level < 8; level++) {
+			const labels = this.localMove(weights);
+			const ids = [...new Set(labels)];
+			if (ids.length === weights.length) break;
+			const lookup = new Map(ids.map((id, i) => [id, i]));
+			const next = ids.map(() => /* @__PURE__ */ new Map());
+			weights.forEach((row, a) => row.forEach((weight, b) => {
+				const x = lookup.get(labels[a]), y = lookup.get(labels[b]);
+				next[x].set(y, (next[x].get(y) ?? 0) + weight);
+			}));
+			members = ids.map((id) => labels.flatMap((label, i) => label === id ? members[i] : []));
+			weights = next;
+		}
+		const result = model.nodes.map(() => 0);
+		members.forEach((list, label) => {
+			for (const index of list) result[index] = label;
+		});
+		return result;
+	}
+	static localMove(weights) {
+		const labels = weights.map((_, i) => i);
+		const strength = weights.map((row) => [...row.values()].reduce((sum, w) => sum + w, 0));
+		const total = strength.reduce((sum, w) => sum + w, 0) || 1;
+		const degree = [...strength];
+		for (let round = 0; round < 20; round++) {
+			let moved = false;
+			weights.forEach((row, node) => {
+				const home = labels[node], gains = /* @__PURE__ */ new Map();
+				for (const [other, weight] of row) if (other !== node) gains.set(labels[other], (gains.get(labels[other]) ?? 0) + weight);
+				degree[home] -= strength[node];
+				const score = (label) => (gains.get(label) ?? 0) - degree[label] * strength[node] / total;
+				let best = home, top = score(home);
+				for (const label of gains.keys()) if (score(label) > top + 1e-9) {
+					best = label;
+					top = score(label);
+				}
+				degree[best] += strength[node];
+				if (best !== home) {
+					labels[node] = best;
+					moved = true;
+				}
+			});
+			if (!moved) break;
+		}
+		return labels;
+	}
+};
+export { GraphCommunities };

package/dist/charts/network/GraphLayouts.js

@@ -0,0 +1,154 @@
+import { GraphMetrics } from "./GraphMetrics.js";
+import { extent, forceCollide, forceLink, forceManyBody, forceSimulation, forceX, forceY, max, randomLcg } from "d3";
+// src/charts/network/GraphLayouts.ts
+var seededVector = (n, seed) => Array.from({ length: n }, (_, i) => Math.sin((i + 1) * 12.9898 + seed * 78.233) * 43758.5453 % 1);
+var dot = (a, b) => a.reduce((sum, value, i) => sum + value * b[i], 0);
+/** Deterministic position solvers. Each returns one point per node index, inside the box. */
+var GraphLayouts = class {
+	/** Settles a d3-force simulation for a fixed tick count from a seeded start. */
+	static force(model, spec) {
+		const { box, radii, ticks = 300, charge = 1, gravity = .06 } = spec;
+		const n = Math.max(1, model.nodes.length), unit = Math.sqrt(box.width * box.height / n);
+		const nodes = model.nodes.map((_, index) => ({
+			index,
+			...spec.start?.[index]
+		}));
+		const links = model.links.map((link) => ({
+			source: link.source.index,
+			target: link.target.index,
+			link
+		}));
+		const shorter = Math.min(box.width, box.height);
+		const simulation = forceSimulation(nodes).randomSource(randomLcg(.42)).stop().force("charge", forceManyBody().strength(-charge * unit * 1.1).distanceMax(shorter)).force("collide", forceCollide().radius((node) => radii[node.index] + 2.5)).force("link", forceLink(links).id((node) => node.index).distance((d) => spec.distance?.(d.link) ?? unit * .72).strength((d) => spec.strength?.(d.link) ?? 1 / Math.min(d.link.source.degree, d.link.target.degree)));
+		if (!spec.start) for (const node of nodes) {
+			node.x += box.width / 2;
+			node.y += box.height / 2;
+		}
+		if (gravity) {
+			simulation.force("x", forceX(box.width / 2).strength(gravity * shorter / box.width));
+			simulation.force("y", forceY(box.height / 2).strength(gravity * shorter / box.height));
+		}
+		for (const [name, force] of Object.entries(spec.forces ?? {})) simulation.force(name, force);
+		simulation.tick(ticks);
+		return nodes.map(({ x, y }) => ({
+			x,
+			y
+		}));
+	}
+	/** Scales points into the box, inset by `pad`. Axes may stretch relative to each other up to `stretch`. */
+	static fit(points, box, pad, stretch = 1.3) {
+		if (!points.length) return points;
+		const xs = points.map((p) => p.x), ys = points.map((p) => p.y);
+		const [x0 = 0, x1 = 0] = extent(xs), [y0 = 0, y1 = 0] = extent(ys);
+		const roomX = Math.max(1, box.width - pad * 2), roomY = Math.max(1, box.height - pad * 2);
+		let sx = x1 > x0 ? roomX / (x1 - x0) : 1, sy = y1 > y0 ? roomY / (y1 - y0) : 1;
+		if (x1 > x0 && y1 > y0) {
+			const base = Math.min(sx, sy);
+			sx = Math.min(sx, base * stretch);
+			sy = Math.min(sy, base * stretch);
+		}
+		const cx = (x0 + x1) / 2, cy = (y0 + y1) / 2;
+		return points.map(({ x, y }) => ({
+			x: box.width / 2 + (x - cx) * sx,
+			y: box.height / 2 + (y - cy) * sy
+		}));
+	}
+	/** Pushes overlapping circles apart while holding them inside the box. */
+	static relax(points, radii, box, rounds = 60) {
+		const nodes = points.map((p, index) => ({
+			index,
+			x: p.x,
+			y: p.y
+		}));
+		const collide = forceCollide().radius((node) => radii[node.index] + 2).iterations(2);
+		const simulation = forceSimulation(nodes).randomSource(randomLcg(.7)).stop().force("collide", collide).velocityDecay(.6);
+		for (let round = 0; round < rounds; round++) {
+			simulation.tick();
+			for (const node of nodes) {
+				const r = radii[node.index] + 1;
+				node.x = Math.max(r, Math.min(box.width - r, node.x));
+				node.y = Math.max(r, Math.min(box.height - r, node.y));
+			}
+		}
+		return nodes.map(({ x, y }) => ({
+			x,
+			y
+		}));
+	}
+	/** All-pairs hop distances; unreachable pairs sit one step past the graph's diameter. */
+	static distances(model) {
+		const rows = model.nodes.map((node) => GraphMetrics.hops(model, node.index));
+		const far = Math.max(1, max(rows, (row) => max(row)) ?? 1) + 1;
+		return rows.map((row) => row.map((hop) => hop < 0 ? far : hop));
+	}
+	/** Stress majorisation (SMACOF), seeded from classical MDS. */
+	static stress(model, rounds = 80) {
+		const d = this.distances(model), n = d.length;
+		const position = this.classicalMds(model);
+		for (let round = 0; round < rounds; round++) for (let i = 0; i < n; i++) {
+			let x = 0, y = 0, total = 0;
+			for (let j = 0; j < n; j++) {
+				if (i === j) continue;
+				const weight = 1 / d[i][j] ** 2, dx = position[i].x - position[j].x, dy = position[i].y - position[j].y;
+				const gap = Math.hypot(dx, dy) || 1e-6;
+				x += weight * (position[j].x + d[i][j] * dx / gap);
+				y += weight * (position[j].y + d[i][j] * dy / gap);
+				total += weight;
+			}
+			if (total) position[i] = {
+				x: x / total,
+				y: y / total
+			};
+		}
+		return position;
+	}
+	/** Classical MDS: the top two eigenvectors of the double-centred squared distance matrix. */
+	static classicalMds(model) {
+		const d = this.distances(model), n = d.length;
+		const squared = d.map((row) => row.map((value) => value * value));
+		const means = squared.map((row) => row.reduce((a, b) => a + b, 0) / n);
+		const mean = means.reduce((a, b) => a + b, 0) / Math.max(1, n);
+		const centred = squared.map((row, i) => row.map((value, j) => -.5 * (value - means[i] - means[j] + mean)));
+		const [a = [], b = []] = this.eigenvectors(n, 2, (v) => centred.map((row) => dot(row, v)));
+		return Array.from({ length: n }, (_, i) => ({
+			x: (a[i] ?? 0) * n,
+			y: (b[i] ?? 0) * n
+		}));
+	}
+	/** Coordinates from the graph Laplacian's two smallest non-trivial eigenvectors. */
+	static spectral(model) {
+		const [a = [], b = []] = this.laplacian(model, 2);
+		return model.nodes.map((_, i) => ({
+			x: a[i] ?? 0,
+			y: b[i] ?? 0
+		}));
+	}
+	/** The `k` smallest non-trivial Laplacian eigenvectors. */
+	static laplacian(model, k) {
+		const n = model.nodes.length, shift = 2 * Math.max(1, ...model.nodes.map((node) => node.degree)) + 1;
+		const flat = new Array(n).fill(1 / Math.sqrt(Math.max(1, n)));
+		return this.eigenvectors(n, k, (v) => v.map((value, i) => {
+			const near = model.neighbours[i];
+			return (shift - near.length) * value + near.reduce((sum, node) => sum + v[node.index], 0);
+		}), [flat]);
+	}
+	/** Power iteration with deflation against `known`. */
+	static eigenvectors(n, k, apply, known = []) {
+		const found = [...known], skip = known.length;
+		for (let c = 0; c < k && n > 0; c++) {
+			let v = seededVector(n, c + 1);
+			for (let round = 0; round < 300; round++) {
+				const w = apply(v);
+				for (const other of found) {
+					const shadow = dot(w, other);
+					for (let i = 0; i < n; i++) w[i] -= shadow * other[i];
+				}
+				const size = Math.sqrt(dot(w, w)) || 1;
+				v = w.map((value) => value / size);
+			}
+			found.push(v);
+		}
+		return found.slice(skip);
+	}
+};
+export { GraphLayouts };

package/dist/charts/network/GraphMetrics.js

@@ -0,0 +1,97 @@
+import { NetworkMetric } from "./networkEnums.js";
+// src/charts/network/GraphMetrics.ts
+/** Node measures, each returned as one number per node index. */
+var GraphMetrics = class {
+	static of(model, metric) {
+		switch (metric) {
+			case NetworkMetric.Degree: return model.nodes.map((node) => node.degree);
+			case NetworkMetric.Value: return model.nodes.map((node) => node.value);
+			case NetworkMetric.Strength: return model.nodes.map((node) => node.strength);
+			case NetworkMetric.Betweenness: return this.betweenness(model);
+			case NetworkMetric.Closeness: return this.closeness(model);
+			case NetworkMetric.PageRank: return this.pageRank(model);
+			case NetworkMetric.KCore: return this.coreness(model);
+			default: return model.nodes.map(() => 1);
+		}
+	}
+	/** Hop counts from `start`; unreachable nodes are -1. */
+	static hops(model, start) {
+		const depth = model.nodes.map(() => -1);
+		if (start < 0 || start >= depth.length) return depth;
+		depth[start] = 0;
+		const queue = [start];
+		for (let head = 0; head < queue.length; head++) {
+			const at = queue[head];
+			for (const next of model.neighbours[at]) if (depth[next.index] === -1) {
+				depth[next.index] = depth[at] + 1;
+				queue.push(next.index);
+			}
+		}
+		return depth;
+	}
+	/** Brandes' algorithm on the unweighted, undirected graph. */
+	static betweenness(model) {
+		const n = model.nodes.length, score = new Array(n).fill(0);
+		for (let s = 0; s < n; s++) {
+			const stack = [], preds = Array.from({ length: n }, () => []);
+			const paths = new Array(n).fill(0), dist = new Array(n).fill(-1);
+			paths[s] = 1;
+			dist[s] = 0;
+			const queue = [s];
+			for (let head = 0; head < queue.length; head++) {
+				const v = queue[head];
+				stack.push(v);
+				for (const { index: w } of model.neighbours[v]) {
+					if (dist[w] < 0) {
+						dist[w] = dist[v] + 1;
+						queue.push(w);
+					}
+					if (dist[w] === dist[v] + 1) {
+						paths[w] += paths[v];
+						preds[w].push(v);
+					}
+				}
+			}
+			const delta = new Array(n).fill(0);
+			for (const w of stack.reverse()) {
+				for (const v of preds[w]) delta[v] += paths[v] / paths[w] * (1 + delta[w]);
+				if (w !== s) score[w] += delta[w];
+			}
+		}
+		return score;
+	}
+	/** Harmonic closeness, so disconnected graphs still score. */
+	static closeness(model) {
+		return model.nodes.map((node) => this.hops(model, node.index).reduce((sum, hop) => sum + (hop > 0 ? 1 / hop : 0), 0));
+	}
+	static pageRank(model, damping = .85, rounds = 40) {
+		const n = model.nodes.length;
+		const outflow = new Array(n).fill(0);
+		for (const { source, value } of model.links) outflow[source.index] += value;
+		let rank = new Array(n).fill(1 / Math.max(1, n));
+		for (let round = 0; round < rounds; round++) {
+			const next = new Array(n).fill((1 - damping) / n);
+			let dangling = 0;
+			for (const node of model.nodes) if (!outflow[node.index]) dangling += rank[node.index];
+			for (const { source, target, value } of model.links) if (outflow[source.index]) next[target.index] += damping * rank[source.index] * value / outflow[source.index];
+			rank = next.map((score) => score + damping * dangling / n);
+		}
+		return rank;
+	}
+	static coreness(model) {
+		const degree = model.nodes.map((node) => node.degree), core = new Array(degree.length).fill(0), done = /* @__PURE__ */ new Set();
+		let level = 0;
+		while (done.size < degree.length) {
+			const next = degree.findIndex((d, i) => !done.has(i) && d <= level);
+			if (next < 0) {
+				level++;
+				continue;
+			}
+			done.add(next);
+			core[next] = level;
+			for (const { index } of model.neighbours[next]) if (!done.has(index)) degree[index]--;
+		}
+		return core;
+	}
+};
+export { GraphMetrics };

package/dist/charts/network/GraphOrder.js

@@ -0,0 +1,56 @@
+import { GraphCommunities } from "./GraphCommunities.js";
+import { GraphLayouts } from "./GraphLayouts.js";
+import { NetworkCommunity, NetworkOrder } from "./networkEnums.js";
+import { ascending, descending } from "d3";
+// src/charts/network/GraphOrder.ts
+/** Linear node orderings for arcs, circles and matrices. */
+var GraphOrder = class {
+	static sort(model, order) {
+		const nodes = [...model.nodes];
+		const groups = model.groups;
+		switch (order) {
+			case NetworkOrder.Group: return nodes.sort((a, b) => groups.indexOf(a.group) - groups.indexOf(b.group) || b.degree - a.degree || a.index - b.index);
+			case NetworkOrder.Degree: return nodes.sort((a, b) => b.degree - a.degree || a.index - b.index);
+			case NetworkOrder.Community: {
+				const labels = GraphCommunities.label(model, NetworkCommunity.Louvain);
+				return nodes.sort((a, b) => labels[a.index] - labels[b.index] || b.degree - a.degree || a.index - b.index);
+			}
+			case NetworkOrder.CuthillMcKee: return this.cuthillMcKee(model);
+			case NetworkOrder.Spectral: {
+				const [fiedler = []] = GraphLayouts.laplacian(model, 1);
+				return nodes.sort((a, b) => ascending(fiedler[a.index], fiedler[b.index]) || a.index - b.index);
+			}
+			default: return nodes;
+		}
+	}
+	/** Reverse Cuthill-McKee: breadth-first from low-degree nodes, reducing matrix bandwidth. */
+	static cuthillMcKee(model) {
+		const seen = /* @__PURE__ */ new Set(), visit = [];
+		for (const start of [...model.nodes].sort((a, b) => a.degree - b.degree || a.index - b.index)) {
+			if (seen.has(start.index)) continue;
+			seen.add(start.index);
+			const queue = [start];
+			for (let head = 0; head < queue.length; head++) {
+				const at = queue[head];
+				visit.push(at);
+				for (const next of [...model.neighbours[at.index]].sort((a, b) => a.degree - b.degree || a.index - b.index)) if (!seen.has(next.index)) {
+					seen.add(next.index);
+					queue.push(next);
+				}
+			}
+		}
+		return visit.reverse();
+	}
+	/** Sorts each list by the mean position of its neighbours in `anchor`, the barycentre heuristic. */
+	static barycentre(list, model, anchor) {
+		return list.map((node, i) => {
+			const near = model.neighbours[node.index].map((other) => anchor.get(other.id)).filter((at) => at !== void 0);
+			return {
+				node,
+				i,
+				at: near.length ? near.reduce((a, b) => a + b, 0) / near.length : i
+			};
+		}).sort((a, b) => descending(b.at, a.at) || a.i - b.i).map(({ node }) => node);
+	}
+};
+export { GraphOrder };

package/dist/charts/network/GraphTrees.js

@@ -0,0 +1,131 @@
+import { NetworkSpanning } from "./networkEnums.js";
+// src/charts/network/GraphTrees.ts
+/** Spanning trees (forests, on disconnected graphs). Each returns the chosen link keys. */
+var GraphTrees = class {
+	static span(model, method, root) {
+		switch (method) {
+			case NetworkSpanning.MaximumWeight: return this.kruskal(model, (a, b) => b.value - a.value);
+			case NetworkSpanning.BreadthFirst: return this.grow(model, root, false);
+			case NetworkSpanning.DepthFirst: return this.grow(model, root, true);
+			case NetworkSpanning.ShortestPath: return this.dijkstra(model, root);
+			default: return this.kruskal(model, (a, b) => a.value - b.value);
+		}
+	}
+	static kruskal(model, compare) {
+		const parent = model.nodes.map((node) => node.index), chosen = /* @__PURE__ */ new Set();
+		const find = (i) => {
+			while (parent[i] !== i) {
+				parent[i] = parent[parent[i]];
+				i = parent[i];
+			}
+			return i;
+		};
+		for (const link of [...model.links].sort((a, b) => compare(a, b) || a.source.index - b.source.index || a.target.index - b.target.index)) {
+			const a = find(link.source.index), b = find(link.target.index);
+			if (a !== b) {
+				parent[a] = b;
+				chosen.add(link.key);
+			}
+		}
+		return chosen;
+	}
+	static between(model) {
+		const lookup = /* @__PURE__ */ new Map();
+		for (const link of model.links) {
+			lookup.set(`${link.source.index}/${link.target.index}`, link);
+			lookup.set(`${link.target.index}/${link.source.index}`, link);
+		}
+		return lookup;
+	}
+	static roots(model, root) {
+		return [root, ...model.nodes];
+	}
+	static grow(model, root, deep) {
+		const lookup = this.between(model), seen = /* @__PURE__ */ new Set(), chosen = /* @__PURE__ */ new Set();
+		for (const start of this.roots(model, root)) {
+			if (seen.has(start.index)) continue;
+			seen.add(start.index);
+			const pending = [{
+				node: start,
+				next: 0
+			}];
+			while (pending.length) {
+				const top = deep ? pending[pending.length - 1] : pending[0];
+				const other = model.neighbours[top.node.index][top.next++];
+				if (!other) {
+					if (deep) pending.pop();
+					else pending.shift();
+					continue;
+				}
+				if (seen.has(other.index)) continue;
+				seen.add(other.index);
+				chosen.add(lookup.get(`${top.node.index}/${other.index}`).key);
+				pending.push({
+					node: other,
+					next: 0
+				});
+			}
+		}
+		return chosen;
+	}
+	/** Link value is read as length: the tree of shortest routes out from the root. */
+	static dijkstra(model, root) {
+		const lookup = this.between(model), chosen = /* @__PURE__ */ new Set(), done = /* @__PURE__ */ new Set();
+		for (const start of this.roots(model, root)) {
+			if (done.has(start.index)) continue;
+			const cost = /* @__PURE__ */ new Map([[start.index, 0]]), via = /* @__PURE__ */ new Map();
+			for (;;) {
+				let at = -1, least = Infinity;
+				for (const [index, value] of cost) if (!done.has(index) && value < least) {
+					at = index;
+					least = value;
+				}
+				if (at < 0) break;
+				done.add(at);
+				const link = via.get(at);
+				if (link) chosen.add(link.key);
+				for (const other of model.neighbours[at]) {
+					const edge = lookup.get(`${at}/${other.index}`), value = least + edge.value;
+					if (value < (cost.get(other.index) ?? Infinity)) {
+						cost.set(other.index, value);
+						via.set(other.index, edge);
+					}
+				}
+			}
+		}
+		return chosen;
+	}
+	/** Nested branches from the chosen links, one child of an unnamed root per component. */
+	static branches(model, chosen, root) {
+		const links = model.nodes.map(() => []);
+		for (const link of model.links) if (chosen.has(link.key)) {
+			links[link.source.index].push(link.target);
+			links[link.target.index].push(link.source);
+		}
+		const seen = /* @__PURE__ */ new Set(), forest = { children: [] };
+		for (const start of this.roots(model, root)) {
+			if (seen.has(start.index)) continue;
+			seen.add(start.index);
+			const top = {
+				node: start,
+				children: []
+			}, stack = [top];
+			forest.children.push(top);
+			while (stack.length) {
+				const branch = stack.pop();
+				for (const next of links[branch.node.index]) {
+					if (seen.has(next.index)) continue;
+					seen.add(next.index);
+					const child = {
+						node: next,
+						children: []
+					};
+					branch.children.push(child);
+					stack.push(child);
+				}
+			}
+		}
+		return forest;
+	}
+};
+export { GraphTrees };