@mstone6969/graph 0.1.0 → 0.2.0

package/dist/charts/hierarchy/SunburstChart.js

@@ -4,7 +4,7 @@ import { HierarchyMeasure, HierarchySort, PolarSweep, SunburstRings, countsKeepD
 import { polarFrame } from "./PolarFrame.js";
 import { TreeSamples } from "./TreeSamples.js";
 import { TreeStyle } from "./TreeStyle.js";
-import { arc, partition } from "d3";
+import { arc, easeCubicOut, interpolateNumber, partition } from "d3";
 // src/charts/hierarchy/SunburstChart.ts
 var degrees = (radians) => radians * 180 / Math.PI;
 /** Concentric rings of arcs: for following shares outward through a few levels of a hierarchy. */
@@ -59,17 +59,10 @@ var SunburstChart = class extends HierarchyChart {
 		const outer = (node) => this.ring(node.depth, levels, frame.radius) - 1;
 		const start = (node) => node.x0 + frame.start;
 		const end = (node) => node.x1 + frame.start;
-		const shape = arc().startAngle(start).endAngle(end).innerRadius(inner).outerRadius(outer).padAngle(4 / frame.radius).padRadius(frame.radius / 2).cornerRadius(3);
-		const closed = arc().startAngle(start).endAngle((node) => start(node) + .001).innerRadius(inner).outerRadius(outer);
+		const shape = (node, from, to) => arc().startAngle(from).endAngle(to).innerRadius(inner).outerRadius(outer).padAngle(4 / frame.radius).padRadius(frame.radius / 2).cornerRadius(3)(node) ?? "";
 		const nodes = root.descendants().filter((node) => node.depth > 0 && node.x1 > node.x0);
 		const arcs = stage.marks("arcs", "path", nodes, (node) => node.data.id).attr("fill", (node) => this.style.fill(node));
-		stage.set(arcs, {
-			d: shape,
-			opacity: 1
-		}, {
-			d: closed,
-			opacity: 0
-		}, this.stagger(arcs, 5));
+		this.sweep(arcs, shape, start, end, frame.start);
 		this.interact(stage, arcs, (node) => node);
 		const notes = nodes.flatMap((node) => this.arcLabel(node, start(node), end(node), inner(node), outer(node)));
 		if (this.options.hole >= .3 && frame.radius * this.options.hole > 24 && this.options.sweep !== PolarSweep.Half) notes.push({
@@ -85,6 +78,20 @@ var SunburstChart = class extends HierarchyChart {
 		});
 		this.labels(stage, "names", notes);
 	}
+	/** Path text cannot tween through arc flags, so every arc opens by angle from `rest`, the whole ring as one fan; later paints move on from the angles held. */
+	sweep(arcs, shape, start, end, rest) {
+		if (!this.animated) {
+			arcs.interrupt().attr("d", (node) => shape(node, start(node), end(node))).property("__angles", (node) => [start(node), end(node)]);
+			return;
+		}
+		arcs.transition().duration(650).ease(easeCubicOut).attrTween("d", function(node) {
+			const held = this;
+			const [from, to] = held.__angles ?? [rest, rest];
+			const a0 = interpolateNumber(from, start(node)), a1 = interpolateNumber(to, end(node));
+			held.__angles = [start(node), end(node)];
+			return (t) => shape(node, a0(t), a1(t));
+		});
+	}
 	arcLabel(node, start, end, inner, outer) {
 		const middle = (start + end) / 2, radius = (inner + outer) / 2;
 		const chord = (end - start) * radius, thick = outer - inner;

package/dist/charts/hierarchy/index.js

@@ -19,11 +19,6 @@ import { PhylogeneticTree } from "./PhylogeneticTree.js";
 import { DecompositionTree } from "./DecompositionTree.js";
 import { MindMap } from "./MindMap.js";
 import { FishboneDiagram } from "./FishboneDiagram.js";
-import { Hierarchy3DChart } from "./Hierarchy3DChart.js";
-import { TreemapSkyline3D } from "./TreemapSkyline3D.js";
-import { SunburstTower3D } from "./SunburstTower3D.js";
-import { ConeTree3D } from "./ConeTree3D.js";
-import { SpherePack3D } from "./SpherePack3D.js";
 import { CirclePackChart } from "./CirclePackChart.js";
 import { ZoomAdjacencyChart } from "./ZoomAdjacencyChart.js";
 import { FlameGraph } from "./FlameGraph.js";
@@ -53,10 +48,6 @@ var hierarchyCatalog = [
 	PhylogeneticTree,
 	DecompositionTree,
 	MindMap,
-	FishboneDiagram,
-	TreemapSkyline3D,
-	SunburstTower3D,
-	ConeTree3D,
-	SpherePack3D
+	FishboneDiagram
 ];
-export { AdjacencyChart, BalloonAngles, BalloonSpread, BalloonTree, CartesianTreeChart, CirclePackChart, CirclePackLayout, CollapsibleTree, ConeAxis, ConeTree3D, DecompositionDrill, DecompositionScale, DecompositionTree, DendrogramChart, DendrogramTip, FishboneDiagram, FishboneHead, FishboneRibs, FlameFlow, FlameGraph, Hierarchy3DChart, HierarchyChart, HierarchyColor, HierarchyMeasure, HierarchySort, IcicleBands, IcicleChart, IcicleZoom, IndentedBars, IndentedTreeChart, MindMap, MindMapNode, MindMapSides, NestedTreemap, OrgCard, OrgChart, PartitionAlign, PartitionChart, PartitionRibbon, PhyloBranches, PhyloLadder, PhyloLayout, PhylogeneticTree, PolarSweep, RadialDendrogram, RadialTreeBase, RadialTreeChart, SkylineHeight, SpherePack3D, SpherePackShell, SpherePackStack, SunburstChart, SunburstRings, SunburstTower3D, TidyTreeChart, TowerProfile, TreeDirection, TreeLinkShape, TreeModel, TreeNodeLinkChart, TreeNodeMark, TreeSamples, TreeSpacing, TreemapChart, TreemapGrouping, TreemapHeader, TreemapSkyline3D, TreemapTile, ZoomAdjacencyChart, ZoomStart, countsKeepDefaultSort, hierarchyCatalog, treeFieldDefaults };
+export { AdjacencyChart, BalloonAngles, BalloonSpread, BalloonTree, CartesianTreeChart, CirclePackChart, CirclePackLayout, CollapsibleTree, ConeAxis, DecompositionDrill, DecompositionScale, DecompositionTree, DendrogramChart, DendrogramTip, FishboneDiagram, FishboneHead, FishboneRibs, FlameFlow, FlameGraph, HierarchyChart, HierarchyColor, HierarchyMeasure, HierarchySort, IcicleBands, IcicleChart, IcicleZoom, IndentedBars, IndentedTreeChart, MindMap, MindMapNode, MindMapSides, NestedTreemap, OrgCard, OrgChart, PartitionAlign, PartitionChart, PartitionRibbon, PhyloBranches, PhyloLadder, PhyloLayout, PhylogeneticTree, PolarSweep, RadialDendrogram, RadialTreeBase, RadialTreeChart, SkylineHeight, SpherePackShell, SpherePackStack, SunburstChart, SunburstRings, TidyTreeChart, TowerProfile, TreeDirection, TreeLinkShape, TreeModel, TreeNodeLinkChart, TreeNodeMark, TreeSamples, TreeSpacing, TreemapChart, TreemapGrouping, TreemapHeader, TreemapTile, ZoomAdjacencyChart, ZoomStart, countsKeepDefaultSort, hierarchyCatalog, treeFieldDefaults };

package/dist/charts/indicators/BulletChart.js

@@ -61,7 +61,12 @@ var BulletChart = class extends IndicatorChart {
 		const rows = readings.slice(0, Math.max(1, Math.floor(room / (vertical ? 40 : 28))));
 		const [low, top] = this.domain();
 		const baseOf = (reading) => reading.target || reading.value || 1;
-		const ceiling = relative ? Math.max(1.3, ...rows.flatMap((r) => [r.value, r.previous ?? 0].map((v) => v / baseOf(r)))) : top, floor = relative ? 0 : low;
+		const edgesOf = (reading) => (this.options.ranges ?? []).map((column) => +(reading.row[column] ?? NaN)).filter(Number.isFinite);
+		const ceiling = relative ? Math.max(1.3, ...rows.flatMap((r) => [
+			r.value,
+			r.previous ?? 0,
+			...edgesOf(r)
+		].map((v) => v / baseOf(r)))) : this.options.max ?? Math.max(top, ...rows.flatMap(edgesOf)), floor = relative ? 0 : low;
 		const gutter = vertical ? 28 : Math.min(width * .26, Math.max(30, ...rows.map((r) => this.textWidth(r.label))) + 10);
 		const length = vertical ? height - 40 : width - gutter - 8;
 		const slot = room / Math.max(1, rows.length);
@@ -97,9 +102,10 @@ var BulletChart = class extends IndicatorChart {
 		};
 		const bands = lanes.flatMap((lane) => {
 			const goal = lane.reading.target ?? lane.ceiling * lane.unit * .8;
+			const own = edgesOf(lane.reading);
 			const stops = [.../* @__PURE__ */ new Set([
 				0,
-				...this.edges().map((edge) => lane.at(edge * goal)),
+				...own.length ? own.map(lane.at) : this.edges().map((edge) => lane.at(edge * goal)),
 				length
 			])].sort((a, b) => a - b);
 			return stops.slice(0, -1).map((from, i) => ({

package/dist/charts/indicators/SpeedometerChart.js

@@ -77,7 +77,7 @@ var SpeedometerChart = class extends DialChart {
 		const band = ctx.marks("trail", "path", trail ? [reading] : [], (d) => d.id, dial.root).attr("fill", this.accent(ctx));
 		this.sweep(band, (d) => d.fraction, (_, f) => this.ring(radius - (outside ? 24 : 44), radius - (outside ? 18 : 38), frame.start, frame.angle(f), 3));
 		ctx.hover(band, (d) => this.tooltip(d));
-		const lines = ctx.marks("graduations", "line", ticks, (d) => d.fraction).attr("stroke", (d) => d.major ? ctx.theme.ink : ctx.theme.inkMuted).attr("stroke-width", (d) => d.major ? 2 : 1);
+		const lines = ctx.marks("axis-ticks", "line", ticks, (d) => d.fraction).attr("stroke", (d) => d.major ? ctx.theme.ink : ctx.theme.inkMuted).attr("stroke-width", (d) => d.major ? 2 : 1);
 		const reach = (d) => radius - (d.major ? 15 : 10);
 		lines.attr("x1", (d) => frame.point(d.fraction, reach(d))[0]).attr("y1", (d) => frame.point(d.fraction, reach(d))[1]).attr("x2", (d) => frame.point(d.fraction, radius - 3)[0]).attr("y2", (d) => frame.point(d.fraction, radius - 3)[1]);
 		const ring = outside ? radius + 12 : radius - 25;

package/dist/charts/indicators/ThermometerChart.js

@@ -90,7 +90,7 @@ var ThermometerChart = class extends IndicatorChart {
 			major: major.has(fraction.toFixed(4)),
 			sign
 		}))) : [];
-		const marks = ctx.marks("ticks", "line", ticks, (d) => d.key).attr("stroke", (d) => d.major ? ctx.theme.inkSecondary : ctx.theme.axis).attr("stroke-width", 1.5);
+		const marks = ctx.marks("axis-ticks", "line", ticks, (d) => d.key).attr("stroke", (d) => d.major ? ctx.theme.inkSecondary : ctx.theme.axis).attr("stroke-width", 1.5);
 		const end = (d, off) => overlay(at(d.fraction), d.sign * off);
 		marks.attr("x1", (d) => end(d, half + 3)[0]).attr("y1", (d) => end(d, half + 3)[1]).attr("x2", (d) => end(d, half + (d.major ? 9 : 6))[0]).attr("y2", (d) => end(d, half + (d.major ? 9 : 6))[1]);
 		const [low, high] = this.domain();

package/dist/charts/lifescience/LoessFit.js

@@ -0,0 +1,113 @@
+// src/charts/lifescience/LoessFit.ts
+var tricube = (r) => (1 - r ** 3) ** 3;
+var median = (values) => {
+	const sorted = [...values].sort((a, b) => a - b), middle = sorted.length / 2;
+	return sorted.length % 2 ? sorted[Math.floor(middle)] : (sorted[middle - 1] + sorted[middle]) / 2;
+};
+/**
+* Robust locally weighted regression: tricube weights over the nearest `span` of the points, then
+* bisquare reweighting of large residuals (Cleveland 1979, JASA 74:829; Cleveland and Devlin 1988,
+* JASA 83:596). Windows and cut-offs follow R's `clowess`, so degree 1 reproduces `stats::lowess`.
+*/
+var LoessFit = class LoessFit {
+	curve;
+	#xs;
+	#ys;
+	#degree;
+	#reach;
+	constructor(points, { span = .3, degree = 1, iterations = 3, knots = 60 } = {}) {
+		const sorted = points.filter(([x, y]) => Number.isFinite(x) && Number.isFinite(y)).sort((a, b) => a[0] - b[0]);
+		this.#xs = sorted.map((point) => point[0]);
+		this.#ys = sorted.map((point) => point[1]);
+		this.#degree = degree;
+		const n = sorted.length;
+		this.#reach = Math.max(degree + 1, Math.min(n, Math.floor(span * n + 1e-7)));
+		const at = this.#knots(knots);
+		const robust = new Array(n).fill(1);
+		let curve = this.#pass(at, robust);
+		for (let pass = 0; pass < iterations && n > 2; pass++) {
+			const residuals = this.#xs.map((x, i) => Math.abs(this.#ys[i] - LoessFit.#read(curve, x)));
+			const scale = 6 * median(residuals);
+			if (scale < 1e-7 * (residuals.reduce((sum, value) => sum + value, 0) / n) || scale === 0) break;
+			residuals.forEach((value, i) => {
+				robust[i] = value <= .001 * scale ? 1 : value <= .999 * scale ? (1 - (value / scale) ** 2) ** 2 : 0;
+			});
+			curve = this.#pass(at, robust);
+		}
+		this.curve = curve;
+	}
+	/** The fit at `x`, held flat past the ends of the data. */
+	at(x) {
+		return LoessFit.#read(this.curve, x);
+	}
+	static #read(curve, x) {
+		if (!curve.length) return 0;
+		if (x <= curve[0][0]) return curve[0][1];
+		if (x >= curve.at(-1)[0]) return curve.at(-1)[1];
+		let low = 0, high = curve.length - 1;
+		while (high - low > 1) {
+			const middle = low + high >> 1;
+			if (curve[middle][0] <= x) low = middle;
+			else high = middle;
+		}
+		const [x0, y0] = curve[low], [x1, y1] = curve[high];
+		return y0 + (x - x0) / (x1 - x0) * (y1 - y0);
+	}
+	#knots(limit) {
+		const distinct = this.#xs.filter((x, i, all) => i === 0 || x !== all[i - 1]);
+		if (distinct.length <= limit) return distinct;
+		return Array.from({ length: limit }, (_, i) => distinct[Math.round(i * (distinct.length - 1) / (limit - 1))]);
+	}
+	#pass(knots, robust) {
+		let left = 0;
+		return knots.map((at) => {
+			while (left + this.#reach < this.#xs.length && at - this.#xs[left] > this.#xs[left + this.#reach] - at) left++;
+			return [at, this.#local(at, left, robust)];
+		});
+	}
+	/** Weighted least squares around `at`, on distances in bandwidths so the system stays well scaled. */
+	#local(at, left, robust) {
+		const xs = this.#xs, ys = this.#ys, last = Math.min(xs.length, left + this.#reach) - 1;
+		const h = Math.max(at - xs[left], xs[last] - at), unit = h || 1;
+		const s = [
+			0,
+			0,
+			0,
+			0,
+			0
+		], t = [
+			0,
+			0,
+			0
+		];
+		for (let j = left; j < xs.length; j++) {
+			const distance = Math.abs(xs[j] - at);
+			if (distance > .999 * h && h > 0) {
+				if (j > last) break;
+				continue;
+			}
+			if (h === 0 && xs[j] !== at) break;
+			const weight = (distance <= .001 * h ? 1 : tricube(distance / h)) * robust[j];
+			const d = (xs[j] - at) / unit;
+			let power = weight;
+			for (let k = 0; k < 5; k++) {
+				s[k] += power;
+				if (k < 3) t[k] += power * ys[j];
+				power *= d;
+			}
+		}
+		if (s[0] <= 0) return ys[Math.min(last, Math.max(left, xs.findIndex((x) => x >= at)))];
+		return LoessFit.#solve(s, t, this.#degree);
+	}
+	/** Intercept of the local polynomial, dropping to a lower degree when the window cannot support one. */
+	static #solve([s0, s1, s2, s3, s4], [t0, t1, t2], degree) {
+		if (degree === 2) {
+			const a = s2 * s4 - s3 * s3, b = s1 * s4 - s3 * s2, c = s1 * s3 - s2 * s2;
+			const det = s0 * a - s1 * b + s2 * c;
+			if (Math.abs(det) > 1e-10 * s0 * s2 * s4) return (t0 * a - t1 * b + t2 * c) / det;
+		}
+		const det = s0 * s2 - s1 * s1;
+		return det > 1e-10 * s0 * s2 ? (t0 * s2 - t1 * s1) / det : t0 / s0;
+	}
+};
+export { LoessFit };

package/dist/charts/lifescience/MaPlot.js

@@ -0,0 +1,337 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { StatisticalChart } from "../statistics/StatisticalChart.js";
+import { StatMath } from "../statistics/StatMath.js";
+import { PValueAdjustment } from "../statistics/VolcanoPlot.js";
+import { FrameworkText } from "../frameworks/FrameworkText.js";
+import { LoessFit } from "./LoessFit.js";
+import { MaPlotSamples } from "./MaPlotSamples.js";
+import { extent, max, min } from "d3";
+// src/charts/lifescience/MaPlot.ts
+/** Which columns hold the expression values. */
+var MaSource = /* @__PURE__ */ function(MaSource) {
+	/** `red` and `green` intensities: M = log2(R/G), A = ½ log2(R·G). */
+	MaSource["TwoChannel"] = "two-channel";
+	/** `m` and `a` as already computed. */
+	MaSource["Values"] = "m-a-values";
+	/** `mean` normalized counts on a log axis against `m`, as DESeq2's `plotMA`. */
+	MaSource["MeanCounts"] = "mean-counts";
+	return MaSource;
+}({});
+/** Correction of M for dye or composition bias before plotting. */
+var MaNormalization = /* @__PURE__ */ function(MaNormalization) {
+	MaNormalization["None"] = "unnormalized";
+	MaNormalization["Median"] = "median";
+	MaNormalization["Loess"] = "loess";
+	return MaNormalization;
+}({});
+/** How the genes that are not significant are drawn. */
+var MaMarks = /* @__PURE__ */ function(MaMarks) {
+	MaMarks["Points"] = "points";
+	MaMarks["Density"] = "hexbin-density";
+	return MaMarks;
+}({});
+var HEX = 9;
+var LABEL_GAP = 6;
+var toPlot = (a, source) => source === "mean-counts" ? 2 ** a : a;
+var median$1 = (values) => {
+	const sorted = [...values].sort((a, b) => a - b), middle = sorted.length / 2;
+	return sorted.length % 2 ? sorted[Math.floor(middle)] ?? 0 : ((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2;
+};
+/**
+* Differential expression as log ratio M against mean average A, which shows intensity-dependent bias
+* that a volcano plot hides. Follows Dudoit et al. (2002, Statistica Sinica 12:111), with the loess
+* normalization of Yang et al. (2002, NAR 30:e15) and the count form of DESeq2's `plotMA`.
+*/
+var MaPlot = class extends StatisticalChart {
+	static meta = {
+		id: "ma-plot",
+		name: "MA plot",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots log ratio against mean expression with a loess trend, to expose intensity bias and the genes that change. The sample genes are synthetic.",
+		tags: [
+			"genomics",
+			"differential expression",
+			"microarray",
+			"rna-seq",
+			"loess"
+		],
+		sample: (seed) => MaPlotSamples.expression(seed),
+		variants: {
+			normalization: Object.values(MaNormalization),
+			marks: Object.values(MaMarks),
+			trend: [true, false],
+			labels: [true, false]
+		}
+	};
+	#memo = null;
+	defaults() {
+		return {
+			gene: "gene",
+			red: "red",
+			green: "green",
+			m: "m",
+			a: "a",
+			mean: "baseMean",
+			pvalue: "pvalue",
+			source: "two-channel",
+			normalization: "unnormalized",
+			adjustment: PValueAdjustment.BenjaminiHochberg,
+			marks: "points",
+			trend: true,
+			labels: true,
+			top: 8,
+			alpha: .05,
+			threshold: 1,
+			span: .3,
+			degree: 1
+		};
+	}
+	axisTitles() {
+		const { source, normalization } = this.options;
+		const counts = source === "mean-counts";
+		const m = counts ? "log2 fold change" : "M";
+		return {
+			x: counts ? "Mean of normalized counts" : "A = ½ log2(R·G)",
+			y: normalization === "unnormalized" ? counts ? m : "M = log2(R/G)" : `${m}, ${normalization} normalized`
+		};
+	}
+	/** `[A, M]` for a row, on the log2 scale; `null` when a log is undefined or a cell is missing. */
+	#measure(row) {
+		const { source, red, green, m, a, mean } = this.options;
+		if (source === "two-channel") {
+			const r = this.number(row[red]), g = this.number(row[green]);
+			return r !== null && g !== null && r > 0 && g > 0 ? [(Math.log2(r) + Math.log2(g)) / 2, Math.log2(r) - Math.log2(g)] : null;
+		}
+		const change = this.number(row[m]);
+		if (change === null) return null;
+		if (source === "m-a-values") {
+			const level = this.number(row[a]);
+			return level === null ? null : [level, change];
+		}
+		const level = this.number(row[mean]);
+		return level !== null && level > 0 ? [Math.log2(level), change] : null;
+	}
+	/** Adjusted p-values by row. Every tested gene is in the family, plotted or not. A missing p stays missing, so that gene is shown but never called. */
+	#adjusted(rows) {
+		const { pvalue, adjustment } = this.options;
+		const raw = rows.map((row) => {
+			const p = this.number(row[pvalue]);
+			return p !== null && p >= 0 && p <= 1 ? p : null;
+		});
+		const tested = raw.filter((p) => p !== null);
+		const corrected = adjustment === PValueAdjustment.BenjaminiHochberg ? StatMath.benjaminiHochberg(tested) : adjustment === PValueAdjustment.Bonferroni ? tested.map((p) => Math.min(1, p * tested.length)) : tested;
+		let next = 0;
+		return raw.map((p) => p === null ? null : corrected[next++]);
+	}
+	#build() {
+		const { gene, normalization, span, degree, trend, alpha, threshold, source } = this.options;
+		const rows = (Array.isArray(this.options.data) ? this.options.data : []).filter((row) => row !== null && typeof row === "object");
+		const family = this.#adjusted(rows);
+		const usable = rows.flatMap((row, i) => {
+			const measured = this.#measure(row);
+			return measured ? [{
+				row,
+				measured,
+				q: family[i]
+			}] : [];
+		});
+		const pairs = usable.map((item) => item.measured);
+		const fit = (points) => new LoessFit(points, {
+			span,
+			degree
+		});
+		const shift = normalization === "loess" ? ((curve) => (a) => curve.at(a))(fit(pairs)) : normalization === "median" ? ((level) => () => level)(median$1(pairs.map((pair) => pair[1]))) : () => 0;
+		const genes = usable.map(({ row, measured: [a, raw] }, index) => {
+			const m = raw - shift(a), q = usable[index].q;
+			const called = q !== null && q < alpha && Math.abs(m) >= threshold && m !== 0;
+			return {
+				index,
+				name: String(row[gene] ?? index + 1),
+				a,
+				m,
+				q,
+				hit: called ? m > 0 ? 1 : -1 : 0
+			};
+		});
+		return {
+			genes,
+			trend: (trend && genes.length > 2 ? fit(genes.map((d) => [d.a, d.m])).curve : []).map(([a, m]) => [toPlot(a, source), m])
+		};
+	}
+	/** Loess is the slow step and pan and zoom repaint constantly, so a frame lasts until its inputs change. */
+	#frame() {
+		const { data, gene, red, green, m, a, mean, pvalue, source, normalization, adjustment, trend, alpha, threshold, span, degree } = this.options;
+		const key = JSON.stringify([
+			data?.length,
+			gene,
+			red,
+			green,
+			m,
+			a,
+			mean,
+			pvalue,
+			source,
+			normalization,
+			adjustment,
+			trend,
+			alpha,
+			threshold,
+			span,
+			degree
+		]);
+		if (this.#memo?.data !== data || this.#memo.key !== key) this.#memo = {
+			data,
+			key,
+			frame: this.#build()
+		};
+		return this.#memo.frame;
+	}
+	/** The computed genes and trend, in log2 A, for reading results in code. */
+	get frame() {
+		return this.#frame();
+	}
+	scales(ctx) {
+		const { source, threshold } = this.options;
+		const { genes, trend } = this.#frame();
+		const reach = Math.max(threshold * 1.25, 1, max(genes, (d) => Math.abs(d.m)) ?? 0, max(trend, (d) => Math.abs(d[1])) ?? 0) * 1.06;
+		const y = this.linear([-reach, reach], [ctx.plot.height, 0]);
+		if (source !== "mean-counts") return {
+			x: this.linear(this.span(extent(genes, (d) => d.a).filter((a) => a !== void 0)), [0, ctx.plot.width]),
+			y
+		};
+		const low = min(genes, (d) => 2 ** d.a), high = max(genes, (d) => 2 ** d.a);
+		return {
+			x: this.logarithmic(low !== void 0 && high !== void 0 ? [low / 1.4, high * 1.4] : [1, 10], [0, ctx.plot.width]),
+			y
+		};
+	}
+	legendItems() {
+		const { data, trend, marks } = this.options;
+		if (!data?.length) return [];
+		return [
+			{
+				key: "Up",
+				color: this.palette.diverging(1)
+			},
+			{
+				key: "Down",
+				color: this.palette.diverging(-1)
+			},
+			{
+				key: marks === "hexbin-density" ? "Not significant, density" : "Not significant",
+				color: this.theme.inkMuted
+			},
+			...trend ? [{
+				key: "Loess trend",
+				color: this.theme.ink
+			}] : []
+		];
+	}
+	/** Pointy-top hexagonal bins in pixels: each gene joins the nearer of the two candidate rows. */
+	#bin(genes, at, { width, height }) {
+		const dx = Math.sqrt(3) * HEX, dy = 1.5 * HEX, bins = /* @__PURE__ */ new Map();
+		for (const gene of genes) {
+			const [x, y] = at(gene);
+			if (x < 0 || x > width || y < 0 || y > height) continue;
+			const row = Math.floor(y / dy);
+			const nearest = [row, row + 1].map((j) => {
+				const i = Math.round(x / dx - (j & 1) / 2), cx = (i + (j & 1) / 2) * dx, cy = j * dy;
+				return {
+					key: `${i},${j}`,
+					x: cx,
+					y: cy,
+					distance: (cx - x) ** 2 + (cy - y) ** 2
+				};
+			}).sort((a, b) => a.distance - b.distance)[0];
+			const bin = bins.get(nearest.key);
+			if (bin) bin.genes.push(gene);
+			else bins.set(nearest.key, {
+				key: nearest.key,
+				x: nearest.x,
+				y: nearest.y,
+				genes: [gene]
+			});
+		}
+		return [...bins.values()];
+	}
+	#density(ctx, bins) {
+		const peak = Math.max(1, max(bins, (bin) => bin.genes.length) ?? 0);
+		const opacity = (bin) => .2 + .8 * Math.sqrt(bin.genes.length / peak);
+		const r = 8, c = r * Math.sqrt(3) / 2;
+		const shape = (bin) => `M${bin.x},${bin.y - r}l${c},${r / 2}v${r}l${-c},${r / 2}l${-c},-4v-8z`;
+		const cells = ctx.marks("density", "path", bins, (bin) => bin.key).attr("fill", ctx.theme.inkMuted);
+		ctx.set(cells, {
+			d: shape,
+			"fill-opacity": opacity
+		}, { "fill-opacity": 0 });
+		ctx.hover(cells, (bin) => ({
+			title: `${bin.genes.length} ${bin.genes.length === 1 ? "gene" : "genes"}`,
+			color: ctx.theme.inkMuted,
+			rows: [["Not significant", bin.genes.length]]
+		}));
+	}
+	plotMarks(ctx, axes) {
+		const { marks, labels, top, threshold, source } = this.options;
+		const { genes, trend } = this.#frame();
+		const [left, right] = axes.x.domain();
+		const dash = "5 4";
+		this.rules(ctx, "zero", [{
+			key: "zero",
+			from: [left, 0],
+			to: [right, 0],
+			strong: true
+		}], axes);
+		this.rules(ctx, "fold", threshold > 0 ? [{
+			key: "up",
+			from: [left, threshold],
+			to: [right, threshold],
+			dash
+		}, {
+			key: "down",
+			from: [left, -threshold],
+			to: [right, -threshold],
+			dash
+		}] : [], axes);
+		const fx = this.scaleX(axes), fy = this.scaleY(axes);
+		const at = (d) => [fx(toPlot(d.a, source)), fy(d.m)];
+		const binned = marks === "hexbin-density";
+		this.#density(ctx, binned ? this.#bin(genes.filter((d) => !d.hit), at, ctx.plot) : []);
+		const color = (d) => d.hit ? ctx.palette.diverging(d.hit) : ctx.theme.inkMuted;
+		const shown = genes.filter((d) => d.hit || !binned).sort((a, b) => Math.abs(a.hit) - Math.abs(b.hit));
+		this.dots(ctx, "genes", shown, at, color, (d) => ({
+			title: d.name,
+			color: color(d),
+			rows: [
+				["A", +d.a.toFixed(3)],
+				["M", +d.m.toFixed(3)],
+				["Adjusted p", d.q === null ? "not tested" : +d.q.toPrecision(3)]
+			]
+		}), {
+			r: (d) => d.hit ? 4 : 2.5,
+			key: (d) => d.index,
+			ring: false,
+			opacity: .8
+		});
+		this.traces(ctx, "trend", trend.length > 1 ? [{
+			key: "Loess trend",
+			color: ctx.theme.ink,
+			points: trend
+		}] : [], axes);
+		const best = labels ? genes.filter((d) => d.hit).sort((a, b) => a.q - b.q || Math.abs(b.m) - Math.abs(a.m)).slice(0, top) : [];
+		this.notes(ctx, "labels", best.map((d) => {
+			const [x, y] = at(d), right = ctx.plot.width - x - LABEL_GAP, left = x - LABEL_GAP;
+			const flip = FrameworkText.width(d.name, 11) > right && left > right;
+			return {
+				key: `${d.index}`,
+				text: FrameworkText.fit(d.name, flip ? left : right, 11),
+				x: x + (flip ? -6 : LABEL_GAP),
+				y: y - 5,
+				anchor: flip ? "end" : "start",
+				tone: "ink"
+			};
+		}));
+	}
+};
+export { MaMarks, MaNormalization, MaPlot, MaSource };

package/dist/charts/lifescience/MaPlotSamples.js

@@ -0,0 +1,35 @@
+import { SampleData } from "../../data/SampleData.js";
+import { StatMath } from "../statistics/StatMath.js";
+// src/charts/lifescience/MaPlotSamples.ts
+var DRAWS = 4;
+/** Invented two-channel expression data, not a measurement: `SYN-` ids, a designed dye bias and designed differential genes. */
+var MaPlotSamples = class MaPlotSamples {
+	/** Spread of M at intensity `a`, which fans out at low signal. */
+	static #noise(a) {
+		return .16 + 1.1 * Math.exp(-(a - 3) / 1.8);
+	}
+	/** The banana shape of an unnormalized dye effect. */
+	static #bias(a) {
+		return .75 * Math.cos(Math.PI * (a - 3) / 12);
+	}
+	/** `{ gene, red, green, baseMean, a, m, pvalue }`, with no p-value for the faintest genes, as after independent filtering. */
+	static expression(seed, count = 1200) {
+		const z = SampleData.distribution(seed, count * DRAWS, 1).map((row) => (row.value - 40) / 8);
+		return Array.from({ length: count }, (_, i) => {
+			const [level, noise, pick, size] = z.slice(i * DRAWS, (i + 1) * DRAWS);
+			const a = Math.max(3, Math.min(15, 8.5 + 2.2 * level));
+			const effect = StatMath.normalCdf(pick) < .08 ? (size < 0 ? -1 : 1) * (1.1 + Math.abs(size) * .8) : 0;
+			const spread = MaPlotSamples.#noise(a), m = MaPlotSamples.#bias(a) + effect + spread * noise;
+			return {
+				gene: `SYN-${String(i + 1).padStart(4, "0")}`,
+				red: +(2 ** (a + m / 2)).toFixed(2),
+				green: +(2 ** (a - m / 2)).toFixed(2),
+				baseMean: +(2 ** a).toFixed(2),
+				a: +a.toFixed(3),
+				m: +m.toFixed(3),
+				pvalue: a < 4 ? null : +StatMath.twoSided((effect + spread * noise) / (spread / 3)).toPrecision(3)
+			};
+		});
+	}
+};
+export { MaPlotSamples };