@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/multivariate/TableChart.js

@@ -0,0 +1,270 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { MultivariateKit } from "./MultivariateKit.js";
+import { MultivariateSample } from "./MultivariateSample.js";
+import { WideTable } from "./WideTable.js";
+import { ascending, descending, extent, max, mean, min, scaleLinear } from "d3";
+// src/charts/multivariate/TableChart.ts
+var TableCell = /* @__PURE__ */ function(TableCell) {
+	TableCell["Bar"] = "bar";
+	TableCell["Lollipop"] = "lollipop";
+	TableCell["Track"] = "track";
+	TableCell["Tile"] = "tile";
+	return TableCell;
+}({});
+var TableBaseline = /* @__PURE__ */ function(TableBaseline) {
+	TableBaseline["Zero"] = "zero";
+	TableBaseline["Mean"] = "mean";
+	return TableBaseline;
+}({});
+var TableOrder = /* @__PURE__ */ function(TableOrder) {
+	TableOrder["Given"] = "given";
+	TableOrder["Descending"] = "descending";
+	TableOrder["Group"] = "group";
+	return TableOrder;
+}({});
+var TableRollup = /* @__PURE__ */ function(TableRollup) {
+	TableRollup["Rows"] = "rows";
+	TableRollup["Groups"] = "groups";
+	return TableRollup;
+}({});
+/** A readable table with a graphic in every cell: exact numbers and shape together. */
+var TableChart = class extends Chart2D {
+	static meta = {
+		id: "table-chart",
+		name: "Table with inline bars",
+		family: ChartFamily.Comparison,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Shows rows of exact values with an inline bar, dot or tile in each numeric cell, for lookup and comparison at once.",
+		tags: [
+			"multivariate",
+			"data bars",
+			"table lens",
+			"inline"
+		],
+		sample: (seed) => {
+			const cities = SampleData.cities(seed);
+			return MultivariateSample.wide(seed, cities.length).map(({ Power: _power, Mass: _mass, ...row }, i) => ({
+				name: cities[i].name,
+				...row
+			}));
+		},
+		variants: {
+			cell: [
+				"bar",
+				"lollipop",
+				"track",
+				"tile"
+			],
+			baseline: ["zero", "mean"],
+			order: [
+				"given",
+				"descending",
+				"group"
+			],
+			rollup: ["rows", "groups"],
+			rowHeight: [22, 28]
+		},
+		valid: (values) => (values.baseline === "zero" || values.cell === "bar" || values.cell === "lollipop") && (values.rollup === "rows" || values.order !== "group") && (values.cell !== "tile" || values.order === "given")
+	};
+	defaults() {
+		return {
+			group: "group",
+			label: "name",
+			cell: "bar",
+			baseline: "zero",
+			order: "given",
+			rollup: "rows",
+			rowHeight: 22
+		};
+	}
+	plotMargin() {
+		return {
+			top: 2,
+			right: 16,
+			bottom: 6,
+			left: 16
+		};
+	}
+	lines(table) {
+		const { label, rollup, order } = this.options;
+		const lines = rollup === "groups" ? table.groups.map((name) => {
+			const own = table.records.filter((record) => record.group === name);
+			return {
+				key: name,
+				name,
+				group: name,
+				values: table.dimensions.map((_, d) => mean(own, (record) => record.values[d]) ?? NaN)
+			};
+		}) : table.records.map((record) => ({
+			key: String(record.index),
+			name: String(record.row[label] ?? `Row ${record.index + 1}`),
+			group: record.group,
+			values: record.values
+		}));
+		if (order === "descending") lines.sort((a, b) => descending(a.values[0], b.values[0]));
+		if (order === "group") lines.sort((a, b) => ascending(table.groups.indexOf(a.group), table.groups.indexOf(b.group)));
+		return lines;
+	}
+	draw(ctx) {
+		const table = WideTable.of(this.options);
+		const k = table.dimensions.length;
+		if (!k || !table.records.length) return;
+		table.groups.forEach(ctx.palette.color);
+		const { width, height } = ctx.plot;
+		const rowH = this.options.rowHeight, head = 20;
+		const all = this.lines(table);
+		const fits = Math.max(1, Math.floor((height - head - 14) / rowH));
+		const shown = all.length > fits + 1 ? all.slice(0, fits) : all;
+		const nameWidth = Math.min(width * .34, 14 + (max(shown, (line) => line.name.length) ?? 8) * 6.4);
+		const cellWidth = (width - nameWidth) / k;
+		const textRoom = cellWidth >= 66 ? 38 : 0;
+		const barWidth = cellWidth - textRoom - 10;
+		const y = (row) => head + row * rowH;
+		const cellX = (column) => nameWidth + column * cellWidth;
+		const headers = [{
+			key: "#",
+			text: "",
+			x: 0,
+			anchor: "start"
+		}, ...table.dimensions.map((name, d) => ({
+			key: name,
+			text: MultivariateKit.trim(name, cellWidth - 8),
+			x: cellX(d) + cellWidth - 8,
+			anchor: "end"
+		}))];
+		ctx.text(ctx.marks("headers", "text", headers, (d) => d.key).attr("font-weight", 600).attr("x", (d) => d.x).attr("y", 12).attr("text-anchor", (d) => d.anchor).text((d) => d.text), 11, "ink");
+		const rules = ctx.marks("rules", "line", [17, ...shown.map((_, i) => y(i + 1) - 1)], (_, i) => i).attr("stroke", (_, i) => i ? ctx.theme.grid : ctx.theme.axis);
+		ctx.set(rules, {
+			x1: 0,
+			x2: width,
+			y1: (d) => d,
+			y2: (d) => d
+		});
+		const names = ctx.marks("names", "text", shown, (line) => line.key).attr("dy", "0.32em").text((line) => MultivariateKit.trim(line.name, nameWidth - 2));
+		ctx.text(names, 11, "ink");
+		ctx.set(names, {
+			x: 0,
+			y: (_, i) => y(i) + (rowH - 1) / 2
+		});
+		const marks = shown.flatMap((line, row) => line.values.flatMap((value, column) => Number.isFinite(value) ? [{
+			key: `${line.key}/${column}`,
+			line,
+			column,
+			value,
+			rowY: y(row)
+		}] : []));
+		const domains = table.dimensions.map((_, d) => {
+			const [low = 0, high = 1] = extent(shown, (line) => line.values[d]);
+			if (this.options.baseline === "mean") {
+				const centre = mean(shown, (line) => line.values[d]) ?? 0, reach = Math.max(centre - low, high - centre) || 1;
+				return {
+					base: centre,
+					scale: scaleLinear([centre - reach, centre + reach], [0, barWidth])
+				};
+			}
+			if (this.options.cell === "track" || this.options.cell === "tile") return {
+				base: low,
+				scale: scaleLinear([low, high === low ? low + 1 : high], [0, barWidth])
+			};
+			return {
+				base: 0,
+				scale: scaleLinear([min([0, low]), max([0, high]) || 1], [0, barWidth])
+			};
+		});
+		this.drawCells(ctx, marks, domains, {
+			rowH,
+			cellX,
+			cellWidth,
+			barWidth,
+			textRoom,
+			table
+		});
+		const rest = all.length - shown.length;
+		const foot = ctx.marks("foot", "text", rest > 0 ? [`+ ${rest} more rows`] : []).text((d) => d);
+		ctx.text(foot, 10, "muted").attr("x", 0).attr("y", y(shown.length) + 10);
+	}
+	drawCells(ctx, marks, domains, layout) {
+		const { rowH, cellX, cellWidth, barWidth, textRoom, table } = layout;
+		const { cell, baseline } = this.options;
+		const at = (d) => domains[d.column].scale(d.value), base = (d) => domains[d.column].scale(domains[d.column].base);
+		const left = (d) => cellX(d.column) + 4;
+		const mid = (d) => d.rowY + (rowH - 1) / 2;
+		const tip = (d) => ({
+			title: d.line.name,
+			color: ctx.palette.color(d.line.group),
+			rows: [[table.dimensions[d.column], +d.value.toFixed(2)]]
+		});
+		const polar = (d) => (d.value - domains[d.column].base) / (domains[d.column].scale.domain()[1] - domains[d.column].base || 1);
+		const hue = (d) => baseline === "mean" ? ctx.palette.diverging(polar(d)) : ctx.palette.color(d.line.group);
+		const thick = Math.min(10, rowH - 12);
+		if (cell === "tile") {
+			const heat = (d) => ctx.palette.sequential(at(d) / barWidth);
+			const tiles = ctx.marks("tiles", "rect", marks, (d) => d.key).attr("fill", heat).attr("rx", 3);
+			ctx.set(tiles, {
+				x: (d) => cellX(d.column) + 2,
+				width: cellWidth - 4,
+				y: (d) => d.rowY + 1,
+				height: rowH - 4
+			}, { width: 0 }, 4);
+			ctx.hover(tiles, tip);
+		}
+		if (cell === "track") {
+			const tracks = ctx.marks("tracks", "line", marks, (d) => d.key).attr("stroke", ctx.theme.grid).attr("stroke-width", 2);
+			ctx.set(tracks, {
+				x1: left,
+				x2: (d) => left(d) + barWidth,
+				y1: mid,
+				y2: mid
+			});
+		}
+		if (cell === "bar") {
+			const bars = ctx.marks("bars", "rect", marks, (d) => d.key).attr("fill", hue).attr("rx", Math.min(3, thick / 2));
+			ctx.set(bars, {
+				x: (d) => left(d) + Math.min(at(d), base(d)),
+				width: (d) => Math.max(1, Math.abs(at(d) - base(d))),
+				y: (d) => mid(d) - thick / 2,
+				height: thick
+			}, {
+				x: (d) => left(d) + base(d),
+				width: 0
+			}, 4);
+			ctx.hover(bars, tip);
+		}
+		if (cell === "lollipop") {
+			const stems = ctx.marks("stems", "line", marks, (d) => d.key).attr("stroke", hue).attr("stroke-width", 2);
+			ctx.set(stems, {
+				x1: (d) => left(d) + base(d),
+				x2: (d) => left(d) + at(d),
+				y1: mid,
+				y2: mid
+			});
+		}
+		if (cell === "lollipop" || cell === "track") {
+			const dots = ctx.marks("dots", "circle", marks, (d) => d.key).attr("fill", hue).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+			ctx.set(dots, {
+				cx: (d) => left(d) + at(d),
+				cy: mid,
+				r: 4.5
+			}, { r: 0 }, 4);
+			ctx.hover(dots, tip);
+		}
+		const showText = cell === "tile" || textRoom > 0;
+		const texts = ctx.marks("values", "text", showText ? marks : [], (d) => d.key).attr("text-anchor", "end").attr("dy", "0.32em").style("font-variant-numeric", "tabular-nums").text((d) => this.format(d.value));
+		ctx.text(texts, 10.5, "ink");
+		if (cell === "tile") texts.attr("fill", (d) => MultivariateKit.inkOn(ctx, ctx.palette.sequential(at(d) / barWidth))).style("pointer-events", "none");
+		ctx.set(texts, {
+			x: (d) => cellX(d.column) + cellWidth - 8,
+			y: mid
+		});
+	}
+	format(value) {
+		return Math.abs(value) >= 1e3 ? Intl.NumberFormat("en", {
+			notation: "compact",
+			maximumFractionDigits: 1
+		}).format(value) : value.toFixed(1);
+	}
+};
+export { TableBaseline, TableCell, TableChart, TableOrder, TableRollup };

package/dist/charts/multivariate/TrellisScatter.js

@@ -0,0 +1,93 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { MultivariateKit, PanelLayout } from "./MultivariateKit.js";
+import { PanelFit, PanelScatter } from "./PanelScatter.js";
+import { extent, group, scaleLinear } from "d3";
+// src/charts/multivariate/TrellisScatter.ts
+var TrellisScales = /* @__PURE__ */ function(TrellisScales) {
+	TrellisScales["Shared"] = "shared";
+	TrellisScales["Free"] = "free";
+	return TrellisScales;
+}({});
+/** Compare one relationship across a category: panels share scales so that shifts in slope and spread stand out. */
+var TrellisScatter = class extends PanelScatter {
+	static meta = {
+		id: "trellis-scatter",
+		name: "Trellis scatter",
+		family: ChartFamily.Relationship,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Repeats a scatter plot in small multiples, one panel per category, to compare a relationship across groups.",
+		tags: [
+			"multivariate",
+			"small multiples",
+			"facet",
+			"lattice"
+		],
+		sample: (seed) => SampleData.points(seed, 120, 4),
+		variants: {
+			layout: [
+				PanelLayout.Wrap,
+				PanelLayout.Row,
+				PanelLayout.Column
+			],
+			fit: [
+				PanelFit.None,
+				PanelFit.Linear,
+				PanelFit.Loess,
+				PanelFit.Ellipse
+			],
+			scales: ["shared", "free"],
+			context: [false, true]
+		}
+	};
+	defaults() {
+		return {
+			x: "x",
+			y: "y",
+			facet: "group",
+			layout: PanelLayout.Wrap,
+			fit: PanelFit.None,
+			scales: "shared",
+			context: false
+		};
+	}
+	get free() {
+		return this.options.scales === "free";
+	}
+	legendItems() {
+		return [];
+	}
+	inside(d, x, y) {
+		const [left, right] = x.domain(), [bottom, top] = y.domain();
+		return d.x >= left && d.x <= right && d.y >= bottom && d.y <= top;
+	}
+	draw(ctx) {
+		const { facet, layout } = this.options;
+		const points = this.points();
+		if (!points.length) return;
+		const faceted = [...group(points, (d) => String(d.row[facet] ?? "All"))];
+		const panels = MultivariateKit.panels(faceted.length, ctx.plot.width, ctx.plot.height, layout, this.free ? 24 : 10);
+		const domain = (rows, axis) => {
+			const [low = 0, high = 1] = extent(rows, (d) => d[axis]);
+			return low === high ? [low - 1, high + 1] : [low, high];
+		};
+		faceted.forEach(([name, rows], i) => {
+			const panel = panels[i];
+			const basis = this.free ? rows : points;
+			const x = scaleLinear(domain(basis, "x"), [4, panel.width - 4]).nice();
+			const y = scaleLinear(domain(basis, "y"), [panel.height - 4, 4]).nice();
+			this.panel(ctx, {
+				panel,
+				name,
+				rows,
+				x,
+				y,
+				context: this.options.context ? points.filter((d) => !rows.includes(d) && this.inside(d, x, y)) : [],
+				showX: this.free || panel.bottom,
+				showY: this.free || panel.left
+			});
+		});
+	}
+};
+export { TrellisScales, TrellisScatter };

package/dist/charts/multivariate/WideTable.js

@@ -0,0 +1,67 @@
+import { deviation, extent, mean } from "d3";
+// src/charts/multivariate/WideTable.ts
+var WideNormal = /* @__PURE__ */ function(WideNormal) {
+	WideNormal["MinMax"] = "min-max";
+	WideNormal["ZScore"] = "z-score";
+	WideNormal["Rank"] = "rank";
+	return WideNormal;
+}({});
+var numeric = (cell) => typeof cell === "number" || cell instanceof Date;
+var toNumber = (cell) => cell === null || cell === void 0 || cell === "" ? NaN : +cell;
+/** Typed view of wide rows: resolves dimensions, keeps gaps as NaN, and normalises columns. */
+var WideTable = class WideTable {
+	groupKey;
+	dimensions;
+	records;
+	groups;
+	constructor(data, dimensions, groupKey = "group") {
+		this.groupKey = groupKey;
+		const rows = Array.isArray(data) ? data : [];
+		this.dimensions = dimensions ?? WideTable.detect(rows, groupKey);
+		this.records = rows.map((row, index) => ({
+			row,
+			index,
+			group: String(row[groupKey] ?? "All"),
+			values: this.dimensions.map((name) => toNumber(row[name]))
+		}));
+		this.groups = [...new Set(this.records.map((record) => record.group))];
+	}
+	static of({ data, dimensions, group }) {
+		return new WideTable(data, dimensions, group);
+	}
+	/** Numeric columns, in first-seen order, ignoring gaps. */
+	static detect(rows, exclude) {
+		return [...new Set(rows.slice(0, 200).flatMap((row) => Object.keys(row)))].filter((name) => name !== exclude).filter((name) => rows.some((row) => numeric(row[name])) && rows.every((row) => row[name] == null || numeric(row[name])));
+	}
+	/** Records with a finite value in every dimension: what projections need. */
+	get complete() {
+		return this.records.filter((record) => record.values.every(Number.isFinite));
+	}
+	column(index, records = this.records) {
+		return records.map((record) => record.values[index]).filter(Number.isFinite);
+	}
+	/** Column bounds, widened so a constant column still has a usable span. */
+	bounds(index) {
+		const [low = 0, high = 1] = extent(this.column(index));
+		return low === high ? [low - 1, high + 1] : [low, high];
+	}
+	/** Per-record values on a common footing; gaps stay NaN. */
+	normalised(kind, records = this.records) {
+		const maps = this.dimensions.map((_, d) => this.normaliser(kind, d));
+		return records.map((record) => record.values.map((value, d) => Number.isFinite(value) ? maps[d](value) : NaN));
+	}
+	normaliser(kind, d) {
+		const column = this.column(d);
+		if (kind === "z-score") {
+			const centre = mean(column) ?? 0, spread = deviation(column) || 1;
+			return (value) => (value - centre) / spread;
+		}
+		if (kind === "rank") {
+			const sorted = [...column].sort((a, b) => a - b);
+			return (value) => sorted.length > 1 ? sorted.indexOf(value) / (sorted.length - 1) : .5;
+		}
+		const [low, high] = this.bounds(d);
+		return (value) => (value - low) / (high - low);
+	}
+};
+export { WideNormal, WideTable };

package/dist/charts/multivariate/index.js

@@ -0,0 +1,52 @@
+import { DistanceMetric, MultivariateMath } from "./MultivariateMath.js";
+import { MultivariateKit, PanelLayout, ProjectionOverlay } from "./MultivariateKit.js";
+import { MultivariateSample } from "./MultivariateSample.js";
+import { WideNormal, WideTable } from "./WideTable.js";
+import { AndrewsBasis, AndrewsCurves, AndrewsDomain, AndrewsFrame, AndrewsLayer } from "./AndrewsCurves.js";
+import { PanelFit, PanelScatter } from "./PanelScatter.js";
+import { ConditionalPlot, ShingleMethod } from "./ConditionalPlot.js";
+import { CrossfilterBinning, CrossfilterForm, CrossfilterHistograms } from "./CrossfilterHistograms.js";
+import { DimensionalStacking, StackingAspect, StackingMark, StackingOrder } from "./DimensionalStacking.js";
+import { GlyphKind, GlyphLayout, GlyphOrder, GlyphPlot } from "./GlyphPlot.js";
+import { HeatedParallelSets, ParallelSetRibbons, ParallelSetSort, ParallelSetWeight } from "./HeatedParallelSets.js";
+import { HyperboxArrangement, HyperboxChart, HyperboxEntity, HyperboxFaces, HyperboxProjection, HyperboxView } from "./HyperboxChart.js";
+import { ProjectionChart } from "./ProjectionChart.js";
+import { MultiDimensionalScaling, ScalingMethod } from "./MultiDimensionalScaling.js";
+import { ParallelAxisOrder, ParallelCoordinates, ParallelLayer, ParallelScale } from "./ParallelCoordinates.js";
+import { InstancedSticks } from "./InstancedSticks.js";
+import { ParallelPlanes3D, PlaneDepth, PlaneLayer } from "./ParallelPlanes3D.js";
+import { PCAScatter3D, PointShape3D } from "./PCAScatter3D.js";
+import { BiplotBasis, BiplotComponents, BiplotScaling, PCABiplot } from "./PCABiplot.js";
+import { PixelBarChart, PixelBarWidth, PixelFill, PixelSort } from "./PixelBarChart.js";
+import { AnchoredProjection } from "./AnchoredProjection.js";
+import { RadViz, RadVizAnchorOrder, RadVizSpacing } from "./RadViz.js";
+import { SankeyMeasure, SankeyMultivariate, SankeyNodeSort } from "./SankeyMultivariate.js";
+import { ScatterplotMatrix, SplomDiagonal, SplomMarker, SplomUpper } from "./ScatterplotMatrix.js";
+import { StarAxisLength, StarCoordinates, StarSpan } from "./StarCoordinates.js";
+import { SurveyAlign, SurveyPlot, SurveyResolution, SurveySort } from "./SurveyPlot.js";
+import { TableBaseline, TableCell, TableChart, TableOrder, TableRollup } from "./TableChart.js";
+import { TrellisScales, TrellisScatter } from "./TrellisScatter.js";
+// src/charts/multivariate/index.ts
+var multivariateCatalog = [
+	ParallelCoordinates,
+	ScatterplotMatrix,
+	AndrewsCurves,
+	RadViz,
+	StarCoordinates,
+	PCABiplot,
+	GlyphPlot,
+	TrellisScatter,
+	HyperboxChart,
+	PixelBarChart,
+	TableChart,
+	ConditionalPlot,
+	HeatedParallelSets,
+	SurveyPlot,
+	DimensionalStacking,
+	CrossfilterHistograms,
+	MultiDimensionalScaling,
+	SankeyMultivariate,
+	ParallelPlanes3D,
+	PCAScatter3D
+];
+export { AnchoredProjection, AndrewsBasis, AndrewsCurves, AndrewsDomain, AndrewsFrame, AndrewsLayer, BiplotBasis, BiplotComponents, BiplotScaling, ConditionalPlot, CrossfilterBinning, CrossfilterForm, CrossfilterHistograms, DimensionalStacking, DistanceMetric, GlyphKind, GlyphLayout, GlyphOrder, GlyphPlot, HeatedParallelSets, HyperboxArrangement, HyperboxChart, HyperboxEntity, HyperboxFaces, HyperboxProjection, HyperboxView, InstancedSticks, MultiDimensionalScaling, MultivariateKit, MultivariateMath, MultivariateSample, PCABiplot, PCAScatter3D, PanelFit, PanelLayout, PanelScatter, ParallelAxisOrder, ParallelCoordinates, ParallelLayer, ParallelPlanes3D, ParallelScale, ParallelSetRibbons, ParallelSetSort, ParallelSetWeight, PixelBarChart, PixelBarWidth, PixelFill, PixelSort, PlaneDepth, PlaneLayer, PointShape3D, ProjectionChart, ProjectionOverlay, RadViz, RadVizAnchorOrder, RadVizSpacing, SankeyMeasure, SankeyMultivariate, SankeyNodeSort, ScalingMethod, ScatterplotMatrix, ShingleMethod, SplomDiagonal, SplomMarker, SplomUpper, StackingAspect, StackingMark, StackingOrder, StarAxisLength, StarCoordinates, StarSpan, SurveyAlign, SurveyPlot, SurveyResolution, SurveySort, TableBaseline, TableCell, TableChart, TableOrder, TableRollup, TrellisScales, TrellisScatter, WideNormal, WideTable, multivariateCatalog };

package/dist/charts/network/AdjacencyMatrixChart.js

@@ -0,0 +1,189 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { GraphOrder } from "./GraphOrder.js";
+import { NetworkOrder } from "./networkEnums.js";
+import { NetworkChart } from "./NetworkChart.js";
+import { NetworkSamples } from "./NetworkSamples.js";
+// src/charts/network/AdjacencyMatrixChart.ts
+/** Mirrored for undirected graphs, Directed reads row to column, Lower removes the redundant half. */
+var MatrixSymmetry = /* @__PURE__ */ function(MatrixSymmetry) {
+	MatrixSymmetry["Mirrored"] = "mirrored";
+	MatrixSymmetry["Directed"] = "directed";
+	MatrixSymmetry["Lower"] = "lower";
+	return MatrixSymmetry;
+}({});
+var MatrixMark = /* @__PURE__ */ function(MatrixMark) {
+	MatrixMark["Square"] = "square";
+	MatrixMark["Sized"] = "sized";
+	MatrixMark["Circle"] = "circle";
+	return MatrixMark;
+}({});
+var MatrixWeight = /* @__PURE__ */ function(MatrixWeight) {
+	MatrixWeight["Binary"] = "binary";
+	MatrixWeight["Linear"] = "linear";
+	MatrixWeight["Log"] = "log";
+	return MatrixWeight;
+}({});
+/** Adjacency matrix: the node-link alternative for dense graphs, immune to edge crossings. */
+var AdjacencyMatrixChart = class extends NetworkChart {
+	static meta = {
+		id: "adjacency-matrix",
+		name: "Adjacency matrix",
+		family: ChartFamily.Network,
+		dimension: Dimension.Two,
+		shape: DataShape.Graph,
+		description: "Shows every possible tie as a cell, so dense graphs stay readable and ordering exposes blocks.",
+		tags: [
+			"network",
+			"matrix",
+			"reorderable matrix",
+			"dense graph"
+		],
+		sample: (seed) => NetworkSamples.clustered(seed, 28, 4),
+		variants: {
+			order: [
+				NetworkOrder.Group,
+				NetworkOrder.Input,
+				NetworkOrder.Degree,
+				NetworkOrder.Community,
+				NetworkOrder.CuthillMcKee,
+				NetworkOrder.Spectral
+			],
+			symmetry: [
+				"mirrored",
+				"directed",
+				"lower"
+			],
+			mark: [
+				"square",
+				"sized",
+				"circle"
+			],
+			weight: [
+				"linear",
+				"log",
+				"binary"
+			]
+		},
+		valid: ({ mark, weight }) => mark === "square" ? weight === "linear" : mark !== "sized" || weight !== "binary"
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			order: NetworkOrder.Group,
+			symmetry: "mirrored",
+			mark: "square",
+			weight: "linear"
+		};
+	}
+	plotMargin() {
+		return {
+			top: 34,
+			right: 16,
+			bottom: 12,
+			left: 16
+		};
+	}
+	cells(model, position) {
+		const { symmetry, weight } = this.options;
+		const top = Math.max(1, ...model.links.map((link) => link.value));
+		const scale = (value) => weight === "log" ? Math.log1p(value) / Math.log1p(top) : weight === "binary" ? 1 : value / top;
+		return model.links.flatMap((link) => {
+			const { source: a, target: b } = link, one = {
+				link,
+				t: scale(link.value)
+			};
+			if (symmetry === "directed") return [{
+				key: `${a.id}/${b.id}`,
+				row: a,
+				column: b,
+				...one
+			}];
+			if (symmetry === "mirrored") return [{
+				key: `${a.id}/${b.id}`,
+				row: a,
+				column: b,
+				...one
+			}, {
+				key: `${b.id}/${a.id}`,
+				row: b,
+				column: a,
+				...one
+			}];
+			const [row, column] = position.get(a.id) > position.get(b.id) ? [a, b] : [b, a];
+			return [{
+				key: `${row.id}/${column.id}`,
+				row,
+				column,
+				...one
+			}];
+		});
+	}
+	/** Weighted cells are sequential, so the group key only applies to binary cells. */
+	legendItems() {
+		return this.options.weight === "binary" ? super.legendItems() : [];
+	}
+	drawNetwork(ctx, model) {
+		const { order, mark, weight } = this.options;
+		const sorted = GraphOrder.sort(model, order), n = sorted.length;
+		const position = new Map(sorted.map((node, i) => [node.id, i]));
+		const side = Math.max(20, Math.min(ctx.plot.width - 30, ctx.plot.height)), step = side / n;
+		const left = Math.max(30, (ctx.plot.width - side) / 2);
+		const gap = step >= 8 ? 2 : step >= 4 ? 1 : .5, full = Math.max(1, step - gap);
+		const frame = ctx.marks("frame", "rect", [0]).attr("fill", ctx.theme.grid).attr("fill-opacity", .35).attr("rx", 3);
+		ctx.set(frame, {
+			x: left - gap / 2,
+			y: -gap / 2,
+			width: side,
+			height: side
+		}, {
+			x: left - gap / 2,
+			y: -gap / 2,
+			width: side,
+			height: side
+		});
+		const cells = this.cells(model, position);
+		const size = (d) => mark === "square" ? full : Math.max(1.5, full * Math.sqrt(d.t));
+		const across = (d) => left + position.get(d.column.id) * step + (full - size(d)) / 2;
+		const down = (d) => position.get(d.row.id) * step + (full - size(d)) / 2;
+		const fill = (d) => {
+			if (weight !== "binary") return ctx.palette.sequential(.25 + .75 * d.t);
+			return d.row.group === d.column.group ? ctx.palette.color(d.row.group) : ctx.theme.inkMuted;
+		};
+		const marks = ctx.marks("cells", "rect", cells, (d) => d.key).attr("fill", fill);
+		ctx.set(marks, {
+			x: across,
+			y: down,
+			width: size,
+			height: size,
+			rx: (d) => mark === "circle" ? size(d) / 2 : Math.min(2, size(d) / 3)
+		}, {
+			x: across,
+			y: down,
+			width: 0,
+			height: 0
+		}, Math.min(2, 300 / cells.length));
+		ctx.hover(marks, (d) => ({
+			title: `${d.row.label} → ${d.column.label}`,
+			rows: [["Weight", d.link.value]]
+		}));
+		const every = Math.max(1, Math.ceil(12 / step));
+		const shown = sorted.filter((_, i) => i % every === 0);
+		const rows = shown.map((node) => ({
+			key: `row-${node.id}`,
+			text: node.label.slice(0, 5),
+			x: left - 5,
+			y: position.get(node.id) * step + full / 2,
+			anchor: "end"
+		}));
+		const columns = shown.map((node) => ({
+			key: `col-${node.id}`,
+			text: node.label.slice(0, 5),
+			x: left + position.get(node.id) * step + full / 2,
+			y: -5,
+			rotate: -90,
+			anchor: "start"
+		}));
+		this.paintAxisLabels(ctx, [...rows, ...columns], "axis-labels", 10);
+	}
+};
+export { AdjacencyMatrixChart, MatrixMark, MatrixSymmetry, MatrixWeight };