@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/network/ContactMap.js

@@ -0,0 +1,186 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { NetworkChart } from "./NetworkChart.js";
+import { NetworkSamples } from "./NetworkSamples.js";
+// src/charts/network/ContactMap.ts
+/** Full square, one triangle, or the triangle rotated flat as in Hi-C maps. */
+var ContactForm = /* @__PURE__ */ function(ContactForm) {
+	ContactForm["Square"] = "square";
+	ContactForm["Upper"] = "upper";
+	ContactForm["Flat"] = "flat";
+	return ContactForm;
+}({});
+var ContactMark = /* @__PURE__ */ function(ContactMark) {
+	ContactMark["Pixel"] = "pixel";
+	ContactMark["Dot"] = "dot";
+	return ContactMark;
+}({});
+var SEPARATION = 4;
+/** Contact map: for ordered chains, such as protein residues or genome bins, where pairs close in space matter. */
+var ContactMap = class extends NetworkChart {
+	static meta = {
+		id: "contact-map",
+		name: "Contact map",
+		family: ChartFamily.Network,
+		dimension: Dimension.Two,
+		shape: DataShape.Graph,
+		description: "Plots which positions along an ordered chain touch, as in protein residues or Hi-C genome bins.",
+		tags: [
+			"network",
+			"contact map",
+			"protein",
+			"hi-c",
+			"matrix",
+			"biology"
+		],
+		sample: (seed) => NetworkSamples.chain(seed),
+		variants: {
+			form: [
+				"square",
+				"upper",
+				"flat"
+			],
+			mark: ["pixel", "dot"],
+			cutoff: [
+				.25,
+				.15,
+				.35
+			],
+			longRange: [false, true],
+			segments: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			form: "square",
+			mark: "pixel",
+			cutoff: .25,
+			longRange: false,
+			segments: true
+		};
+	}
+	legendItems() {
+		return this.options.segments ? super.legendItems() : [];
+	}
+	contacts(model) {
+		const { cutoff, longRange } = this.options;
+		return model.links.flatMap((link) => {
+			const [a, b] = link.source.index < link.target.index ? [link.source, link.target] : [link.target, link.source];
+			return link.value >= cutoff && (!longRange || b.index - a.index >= SEPARATION) ? [{
+				key: link.key,
+				a: a.index,
+				b: b.index,
+				value: link.value,
+				first: a,
+				second: b
+			}] : [];
+		});
+	}
+	drawNetwork(ctx, model) {
+		const { form, mark, segments } = this.options;
+		const flat = form === "flat", n = model.nodes.length;
+		const strip = segments ? 8 : 0, axisRoom = 16;
+		const { width, height } = ctx.plot;
+		const side = Math.max(20, flat ? Math.min(width - 12, (height - strip - axisRoom) * 2) : Math.min(width - 30, height - strip - axisRoom));
+		const step = side / n, left = flat ? (width - side) / 2 : (width - side) / 2 + 12;
+		const top = flat ? height - axisRoom - strip : strip;
+		const contacts = this.contacts(model);
+		const high = Math.max(1e-9, ...contacts.map((c) => c.value)), low = Math.min(...contacts.map((c) => c.value), high);
+		const tone = (value) => ctx.palette.sequential(.3 + .7 * (high > low ? (value - low) / (high - low) : 1));
+		const centre = (row, column) => flat ? [left + (row + column + 1) / 2 * step, top - (column - row) / 2 * step] : [left + (column + .5) * step, top + (row + .5) * step];
+		const cell = (row, column) => {
+			const [x, y] = centre(row, column), reach = step * (flat ? .5 : .5);
+			if (mark === "dot") {
+				const r = Math.max(.8, step * .4);
+				return `M${(x - r).toFixed(2)},${y.toFixed(2)}a${r.toFixed(2)},${r.toFixed(2)} 0 1 0 ${(r * 2).toFixed(2)},0a${r.toFixed(2)},${r.toFixed(2)} 0 1 0 ${(-r * 2).toFixed(2)},0Z`;
+			}
+			if (flat) return `M${x.toFixed(2)},${(y - reach).toFixed(2)}L${(x + reach).toFixed(2)},${y.toFixed(2)}L${x.toFixed(2)},${(y + reach).toFixed(2)}L${(x - reach).toFixed(2)},${y.toFixed(2)}Z`;
+			const inner = Math.max(.8, step - (step > 6 ? 1 : .25));
+			return `M${(x - inner / 2).toFixed(2)},${(y - inner / 2).toFixed(2)}h${inner.toFixed(2)}v${inner.toFixed(2)}h${(-inner).toFixed(2)}Z`;
+		};
+		const pairs = contacts.flatMap((c) => form === "square" ? [{
+			...c,
+			d: cell(c.a, c.b),
+			id: c.key
+		}, {
+			...c,
+			d: cell(c.b, c.a),
+			id: `${c.key}/mirror`
+		}] : [{
+			...c,
+			d: cell(c.a, c.b),
+			id: c.key
+		}]);
+		const base = flat ? [`M${left.toFixed(2)},${top.toFixed(2)}L${(left + side).toFixed(2)},${top.toFixed(2)}`] : [`M${left.toFixed(2)},${top.toFixed(2)}L${(left + side).toFixed(2)},${(top + side).toFixed(2)}`];
+		const frame = !flat && form === "square" ? [`M${left.toFixed(2)},${top.toFixed(2)}h${side.toFixed(2)}v${side.toFixed(2)}h${(-side).toFixed(2)}Z`] : !flat ? [`M${left.toFixed(2)},${top.toFixed(2)}h${side.toFixed(2)}v${side.toFixed(2)}Z`] : [`M${left.toFixed(2)},${top.toFixed(2)}L${(left + side / 2).toFixed(2)},${(top - side / 2).toFixed(2)}L${(left + side).toFixed(2)},${top.toFixed(2)}Z`];
+		const back = ctx.marks("frame", "path", frame).attr("fill", ctx.theme.grid).attr("fill-opacity", .35);
+		ctx.set(back, { d: (d) => d }, { d: (d) => d });
+		const diagonal = ctx.marks("diagonal", "path", base).attr("fill", "none").attr("stroke", ctx.theme.axis).attr("stroke-width", 1.5);
+		ctx.set(diagonal, { d: (d) => d }, { d: (d) => d });
+		const marks = ctx.marks("contacts", "path", pairs, (d) => d.id).attr("fill", (d) => tone(d.value));
+		ctx.set(marks, {
+			d: (d) => d.d,
+			opacity: 1
+		}, {
+			d: (d) => d.d,
+			opacity: 0
+		});
+		ctx.hover(marks, (d) => ({
+			title: `${d.first.label} – ${d.second.label}`,
+			rows: [["Strength", d.value], ["Separation", d.b - d.a]]
+		}));
+		const blocks = [];
+		for (const node of model.nodes) {
+			const last = blocks[blocks.length - 1];
+			if (last?.group === node.group) last.end = node.index + 1;
+			else blocks.push({
+				group: node.group,
+				start: node.index,
+				end: node.index + 1
+			});
+		}
+		const lane = segments ? blocks : [];
+		const bars = ctx.marks("segments", "rect", lane, (d) => d.start).attr("fill", (d) => ctx.palette.color(d.group)).attr("rx", 2);
+		const barAt = {
+			x: (d) => left + d.start * step,
+			y: flat ? top + 3 : 0,
+			width: (d) => Math.max(1, (d.end - d.start) * step - 2),
+			height: 5
+		};
+		ctx.set(bars, barAt, barAt);
+		ctx.hover(bars, (d) => ({
+			title: d.group,
+			color: ctx.palette.color(d.group),
+			rows: [["From", model.nodes[d.start].label], ["To", model.nodes[d.end - 1].label]]
+		}));
+		const every = [
+			5,
+			10,
+			20,
+			50,
+			100,
+			200,
+			500
+		].find((k) => k * step >= 34) ?? 1e3;
+		const ticks = model.nodes.filter((node) => (node.index + 1) % every === 0).map((node) => flat ? {
+			key: node.id,
+			text: String(node.index + 1),
+			x: left + (node.index + .5) * step,
+			y: top + strip + 8
+		} : {
+			key: node.id,
+			text: String(node.index + 1),
+			x: left + (node.index + .5) * step,
+			y: top + side + 8
+		});
+		const rows = flat ? [] : model.nodes.filter((node) => (node.index + 1) % every === 0).map((node) => ({
+			key: `row-${node.id}`,
+			text: String(node.index + 1),
+			x: left - 5,
+			y: top + (node.index + .5) * step,
+			anchor: "end"
+		}));
+		this.paintAxisLabels(ctx, [...ticks, ...rows], "axis-labels", 10);
+	}
+};
+export { ContactForm, ContactMap, ContactMark };

package/dist/charts/network/EdgeRouter.js

@@ -0,0 +1,181 @@
+import { NetworkEdge } from "./networkEnums.js";
+import { curveBundle, line } from "d3";
+// src/charts/network/EdgeRouter.ts
+var round = (value) => +value.toFixed(2);
+var angle = (from, to) => Math.atan2(to.y - from.y, to.x - from.x);
+var lerp = (a, b, t) => ({
+	x: a.x + (b.x - a.x) * t,
+	y: a.y + (b.y - a.y) * t
+});
+/** Turns a pair of points into SVG path data. Every edge shape in the module comes through here. */
+var EdgeRouter = class {
+	static route(shape, input) {
+		switch (shape) {
+			case NetworkEdge.Arc: return this.quadratic(input, this.bend(input, .2));
+			case NetworkEdge.Curve: return this.quadratic(input, lerp(lerp(input.a, input.b, .5), input.center, .55));
+			case NetworkEdge.Tapered: return this.taper(input);
+			case NetworkEdge.Bundled: return this.bundled(input);
+			case NetworkEdge.Orthogonal: return this.orthogonal(input);
+			case NetworkEdge.Bump: return this.bump(input);
+			default: return this.quadratic(input, lerp(input.a, input.b, .5), true);
+		}
+	}
+	static bend({ a, b }, amount) {
+		const mid = lerp(a, b, .5);
+		return {
+			x: mid.x + (b.y - a.y) * amount,
+			y: mid.y - (b.x - a.x) * amount
+		};
+	}
+	static quadratic({ a, b, rb, ra, arrow }, control, straight = false) {
+		const span = Math.hypot(b.x - a.x, b.y - a.y) || 1;
+		const t0 = arrow ? Math.min(.45, (ra + 1) / span) : 0, t1 = arrow ? Math.max(.55, 1 - (rb + 3) / span) : 1;
+		const p0 = this.at(a, control, b, t0), p1 = this.at(a, control, b, t1);
+		const c = lerp(lerp(a, control, t0), lerp(control, b, t0), t1);
+		const head = `M${round(p0.x)},${round(p0.y)}`;
+		return {
+			d: straight ? `${head}L${round(p1.x)},${round(p1.y)}` : `${head}Q${round(c.x)},${round(c.y)} ${round(p1.x)},${round(p1.y)}`,
+			tip: arrow ? {
+				...p1,
+				angle: angle(lerp(a, control, t1), lerp(control, b, t1))
+			} : void 0
+		};
+	}
+	static at(a, c, b, t) {
+		return lerp(lerp(a, c, t), lerp(c, b, t), t);
+	}
+	static taper({ a, b }) {
+		const c = this.bend({
+			a,
+			b
+		}, .12), span = Math.hypot(b.x - a.x, b.y - a.y) || 1;
+		const nx = (b.y - a.y) / span * 2.2, ny = -(b.x - a.x) / span * 2.2;
+		return {
+			d: `M${round(a.x + nx)},${round(a.y + ny)}Q${round(c.x + nx)},${round(c.y + ny)} ${round(b.x)},${round(b.y)}Q${round(c.x - nx)},${round(c.y - ny)} ${round(a.x - nx)},${round(a.y - ny)}Z`,
+			solid: true
+		};
+	}
+	static bundled({ a, b, via = [], bundle = .8, arrow, rb }) {
+		const heading = angle(via[via.length - 1] ?? a, b);
+		const end = arrow ? {
+			x: b.x - Math.cos(heading) * (rb + 3),
+			y: b.y - Math.sin(heading) * (rb + 3)
+		} : b;
+		return {
+			d: line((p) => round(p.x), (p) => round(p.y)).curve(curveBundle.beta(bundle))([
+				a,
+				...via,
+				end
+			]) ?? "",
+			tip: arrow ? {
+				...end,
+				angle: heading
+			} : void 0
+		};
+	}
+	static orthogonal({ a, b, axis = "x", arrow, rb }) {
+		const corner = 5;
+		if (Math.abs(a.x - b.x) < .5 || Math.abs(a.y - b.y) < .5) return this.quadratic({
+			a,
+			b,
+			ra: 0,
+			rb,
+			center: a,
+			arrow
+		}, lerp(a, b, .5), true);
+		const flip = axis === "y";
+		const [ax, ay, bx, by] = flip ? [
+			a.y,
+			a.x,
+			b.y,
+			b.x
+		] : [
+			a.x,
+			a.y,
+			b.x,
+			b.y
+		];
+		const mid = (ax + bx) / 2, r = Math.min(corner, Math.abs(bx - ax) / 2, Math.abs(by - ay) / 2);
+		const sx = Math.sign(bx - ax), sy = Math.sign(by - ay), end = arrow ? bx - sx * (rb + 3) : bx;
+		return {
+			d: [
+				[
+					"M",
+					ax,
+					ay
+				],
+				[
+					"L",
+					mid - sx * r,
+					ay
+				],
+				[
+					"Q",
+					mid,
+					ay
+				],
+				[
+					"",
+					mid,
+					ay + sy * r
+				],
+				[
+					"L",
+					mid,
+					by - sy * r
+				],
+				[
+					"Q",
+					mid,
+					by
+				],
+				[
+					"",
+					mid + sx * r,
+					by
+				],
+				[
+					"L",
+					end,
+					by
+				]
+			].map(([verb, x, y]) => {
+				const [u, v] = flip ? [y, x] : [x, y];
+				return `${verb}${round(u)},${round(v)}${verb === "Q" ? " " : ""}`;
+			}).join(""),
+			tip: arrow ? flip ? {
+				x: by,
+				y: end,
+				angle: sx > 0 ? Math.PI / 2 : -Math.PI / 2
+			} : {
+				x: end,
+				y: by,
+				angle: sx > 0 ? 0 : Math.PI
+			} : void 0
+		};
+	}
+	static bump({ a, b, axis = "x", arrow, rb }) {
+		const gap = arrow ? rb + 3 : 0;
+		if (axis === "x") {
+			const end = b.x - Math.sign(b.x - a.x || 1) * gap, mid = (a.x + end) / 2;
+			return {
+				d: `M${round(a.x)},${round(a.y)}C${round(mid)},${round(a.y)} ${round(mid)},${round(b.y)} ${round(end)},${round(b.y)}`,
+				tip: arrow ? {
+					x: end,
+					y: b.y,
+					angle: b.x >= a.x ? 0 : Math.PI
+				} : void 0
+			};
+		}
+		const end = b.y - Math.sign(b.y - a.y || 1) * gap, mid = (a.y + end) / 2;
+		return {
+			d: `M${round(a.x)},${round(a.y)}C${round(a.x)},${round(mid)} ${round(b.x)},${round(mid)} ${round(b.x)},${round(end)}`,
+			tip: arrow ? {
+				x: b.x,
+				y: end,
+				angle: b.y >= a.y ? Math.PI / 2 : -Math.PI / 2
+			} : void 0
+		};
+	}
+};
+export { EdgeRouter };

package/dist/charts/network/EgoNetworkChart.js

@@ -0,0 +1,157 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { GraphLayouts } from "./GraphLayouts.js";
+import { GraphMetrics } from "./GraphMetrics.js";
+import { GraphOrder } from "./GraphOrder.js";
+import { NetworkEdge, NetworkMetric } from "./networkEnums.js";
+import { NetworkSamples } from "./NetworkSamples.js";
+import { NodeLinkNetwork } from "./NodeLinkNetwork.js";
+import { forceRadial } from "d3";
+// src/charts/network/EgoNetworkChart.ts
+var EgoLayout = /* @__PURE__ */ function(EgoLayout) {
+	EgoLayout["Rings"] = "rings";
+	EgoLayout["Sectors"] = "sectors";
+	EgoLayout["Force"] = "force";
+	return EgoLayout;
+}({});
+/** One entity's neighbourhood: use when the question is about a person, an account or a server, not the whole graph. */
+var EgoNetworkChart = class extends NodeLinkNetwork {
+	static meta = {
+		id: "ego-network",
+		name: "Ego network",
+		family: ChartFamily.Network,
+		dimension: Dimension.Two,
+		shape: DataShape.Graph,
+		description: "Focuses on one node and the neighbours within a few hops, drawn outward from that node.",
+		tags: [
+			"network",
+			"ego",
+			"neighbourhood",
+			"personal network"
+		],
+		sample: (seed) => NetworkSamples.clustered(seed, 44, 4),
+		variants: {
+			hops: [
+				2,
+				1,
+				3
+			],
+			layout: [
+				"rings",
+				"sectors",
+				"force"
+			],
+			ties: [true, false],
+			nodeSize: [
+				NetworkMetric.Uniform,
+				NetworkMetric.Degree,
+				NetworkMetric.Value
+			],
+			edge: [NetworkEdge.Straight, NetworkEdge.Curve]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			hops: 2,
+			layout: "rings",
+			ties: true,
+			nodeSize: NetworkMetric.Uniform
+		};
+	}
+	start(model) {
+		const { focus } = this.options;
+		return focus !== void 0 && model.byId.get(focus) || model.hub;
+	}
+	view(model) {
+		const hops = GraphMetrics.hops(model, this.start(model).index), limit = this.options.hops;
+		const keep = model.nodes.filter((node) => hops[node.index] >= 0 && hops[node.index] <= limit);
+		return model.subgraph(keep, (link) => this.options.ties || Math.abs(hops[link.source.index] - hops[link.target.index]) === 1);
+	}
+	shells(ctx, model) {
+		const hops = GraphMetrics.hops(model, this.start(model).index), top = Math.max(1, ...hops);
+		return {
+			hops,
+			top,
+			step: (Math.min(ctx.plot.width, ctx.plot.height) / 2 - 16) / top
+		};
+	}
+	radii(model, metric, ctx) {
+		const { hops, step, top } = this.shells(ctx, model);
+		const counts = Array.from({ length: top + 1 }, (_, hop) => hops.filter((value) => value === hop).length);
+		const tight = Math.min(...counts.map((count, hop) => hop ? 2 * Math.PI * hop * step / count : Infinity));
+		return this.capped(super.radii(model, metric, ctx), Math.min(tight * .5, step * .4));
+	}
+	place(ctx, model, radii) {
+		const { layout } = this.options, { hops, top, step } = this.shells(ctx, model);
+		const { x: cx, y: cy } = this.centre(ctx), ego = this.start(model);
+		if (layout === "force") {
+			const ring = forceRadial((node) => hops[node.index] * step, cx, cy).strength(.8);
+			const settled = GraphLayouts.force(model, {
+				box: ctx.plot,
+				radii,
+				forces: { ring },
+				gravity: 0
+			});
+			return GraphLayouts.relax(settled, radii, ctx.plot);
+		}
+		const points = [], angle = /* @__PURE__ */ new Map([[ego.id, 0]]);
+		points[ego.index] = {
+			x: cx,
+			y: cy
+		};
+		const groups = model.groups;
+		for (let hop = 1; hop <= top; hop++) {
+			const shell = model.nodes.filter((node) => hops[node.index] === hop);
+			if (layout === "sectors") {
+				const total = model.nodes.length - 1 || 1;
+				let start = -Math.PI / 2;
+				for (const group of groups) {
+					const share = model.nodes.filter((node) => node.group === group && node.id !== ego.id).length / total * 2 * Math.PI;
+					const members = shell.filter((node) => node.group === group);
+					members.forEach((node, i) => {
+						const turn = start + share * ((i + .5) / members.length);
+						points[node.index] = {
+							x: cx + Math.cos(turn) * hop * step,
+							y: cy + Math.sin(turn) * hop * step
+						};
+					});
+					start += share;
+				}
+				continue;
+			}
+			const sorted = GraphOrder.barycentre(shell, model, angle);
+			sorted.forEach((node, i) => {
+				const turn = i / sorted.length * 2 * Math.PI - Math.PI / 2;
+				angle.set(node.id, i / sorted.length);
+				points[node.index] = {
+					x: cx + Math.cos(turn) * hop * step,
+					y: cy + Math.sin(turn) * hop * step
+				};
+			});
+		}
+		return points;
+	}
+	underlay(ctx, model) {
+		const { top, step } = this.shells(ctx, model), { x, y } = this.centre(ctx);
+		const levels = Array.from({ length: top }, (_, hop) => (hop + 1) * step);
+		const guides = ctx.marks("guides", "circle", this.options.layout === "force" ? [] : levels).attr("fill", "none").attr("stroke", ctx.theme.grid).attr("stroke-width", 1.5);
+		ctx.set(guides, {
+			cx: x,
+			cy: y,
+			r: (r) => r
+		}, {
+			cx: x,
+			cy: y,
+			r: 0
+		});
+	}
+	drawLabelSide(ctx, placed) {
+		const { x } = this.centre(ctx);
+		return placed.map((d) => ({
+			...d,
+			r: d.r,
+			side: d.x >= x ? "right" : "left"
+		}));
+	}
+};
+export { EgoLayout, EgoNetworkChart };

package/dist/charts/network/ForceGraphChart.js

@@ -0,0 +1,97 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { GraphLayouts } from "./GraphLayouts.js";
+import { GraphMetrics } from "./GraphMetrics.js";
+import { NetworkEdge, NetworkMetric } from "./networkEnums.js";
+import { NetworkSamples } from "./NetworkSamples.js";
+import { NodeLinkNetwork } from "./NodeLinkNetwork.js";
+import { forceRadial, forceX, forceY } from "d3";
+// src/charts/network/ForceGraphChart.ts
+/** Extra structure imposed on a force layout. */
+var ForceConstraint = /* @__PURE__ */ function(ForceConstraint) {
+	ForceConstraint["Free"] = "free";
+	ForceConstraint["Radial"] = "radial";
+	ForceConstraint["Layered"] = "layered";
+	ForceConstraint["Columns"] = "columns";
+	return ForceConstraint;
+}({});
+/** The default way to see a network's overall shape: clusters, hubs and bridges emerge from physics. */
+var ForceGraphChart = class extends NodeLinkNetwork {
+	static meta = {
+		id: "force-graph",
+		name: "Force-directed graph",
+		family: ChartFamily.Network,
+		dimension: Dimension.Two,
+		shape: DataShape.Graph,
+		description: "Settles nodes under simulated forces so clusters, hubs and bridges in a network become visible.",
+		tags: [
+			"network",
+			"node-link",
+			"d3-force",
+			"graph"
+		],
+		sample: (seed) => NetworkSamples.clustered(seed),
+		variants: {
+			nodeSize: [
+				NetworkMetric.Degree,
+				NetworkMetric.Uniform,
+				NetworkMetric.Value,
+				NetworkMetric.PageRank
+			],
+			edge: [
+				NetworkEdge.Straight,
+				NetworkEdge.Arc,
+				NetworkEdge.Tapered
+			],
+			constraint: [
+				"free",
+				"radial",
+				"layered",
+				"columns"
+			],
+			weightedLength: [false, true],
+			arrows: [false, true]
+		},
+		valid: ({ edge, arrows }) => !(edge === NetworkEdge.Tapered && arrows)
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			constraint: "free",
+			weightedLength: false,
+			ticks: 300
+		};
+	}
+	forces(ctx, model) {
+		const { width, height } = ctx.plot;
+		const short = Math.min(width, height);
+		switch (this.options.constraint) {
+			case "radial": {
+				const top = Math.max(1, ...model.nodes.map((node) => node.degree));
+				return { ring: forceRadial((node) => (1 - model.nodes[node.index].degree / top) * short * .48, width / 2, height / 2).strength(.7) };
+			}
+			case "layered": {
+				const depth = GraphMetrics.hops(model, model.hub.index), top = Math.max(1, ...depth);
+				return { layer: forceY((node) => (Math.max(0, depth[node.index]) + .5) / (top + 1) * height).strength(.9) };
+			}
+			case "columns": {
+				const groups = model.groups;
+				return { column: forceX((node) => (groups.indexOf(model.nodes[node.index].group) + .5) / groups.length * width).strength(.3) };
+			}
+			default: return {};
+		}
+	}
+	place(ctx, model, radii) {
+		const unit = Math.sqrt(ctx.plot.width * ctx.plot.height / model.nodes.length);
+		const top = Math.max(1, ...model.links.map((link) => link.value));
+		const raw = GraphLayouts.force(model, {
+			box: ctx.plot,
+			radii,
+			ticks: this.options.ticks,
+			forces: this.forces(ctx, model),
+			distance: this.options.weightedLength ? (link) => unit * (1.3 - link.value / top) : void 0
+		});
+		const pad = Math.max(...radii) + 2;
+		return GraphLayouts.relax(GraphLayouts.fit(raw, ctx.plot, pad), radii, ctx.plot);
+	}
+};
+export { ForceConstraint, ForceGraphChart };