@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/indicators/index.js

@@ -0,0 +1,49 @@
+import { BatteryRim, BulletMeasure, BulletScale, BulletTarget, DeltaForm, DeltaLayout, DeltaMode, DeltaSort, GaugeMarker, GaugeScale, GaugeSweep, HarveyForm, HarveyLayout, IndicatorCap, IndicatorStatus, KpiCompare, KpiDelta, KpiLayout, KpiSpark, LiquidLevel, LiquidShape, LiquidWave, MeterForm, MeterLabel, MeterZones, NeedleStyle, NumeralPlacement, RadialLabel, RadialOrder, RatingGlyph, RatingLayout, RatingPrecision, RingDirection, RingOverflow, RingStart, RingTrack, ScoreDensity, ScoreGauge, ScoreSort, ScoreStatus, SegmentLit, SegmentMark, StepForm, StepLabels, TallyBundle, TallyLayout, TargetMark, TargetPlacement, TargetRingScale, TargetRingStyle, ThermometerBase, ThermometerScale, ThermometerSide, TickDensity, TrafficHousing, TrafficLayout, VuResponse } from "./IndicatorEnums.js";
+import { IndicatorChart } from "./IndicatorChart.js";
+import { ActivityRings } from "./ActivityRings.js";
+import { BatteryChart } from "./BatteryChart.js";
+import { BulletChart } from "./BulletChart.js";
+import { DeltaIndicator } from "./DeltaIndicator.js";
+import { DialChart } from "./DialChart.js";
+import { GaugeChart } from "./GaugeChart.js";
+import { HarveyBalls } from "./HarveyBalls.js";
+import { KpiTile } from "./KpiTile.js";
+import { LiquidFillGauge } from "./LiquidFillGauge.js";
+import { MeterChart } from "./MeterChart.js";
+import { ProgressRing } from "./ProgressRing.js";
+import { RadialProgress } from "./RadialProgress.js";
+import { RatingStars } from "./RatingStars.js";
+import { ScoreCard } from "./ScoreCard.js";
+import { SegmentedGauge } from "./SegmentedGauge.js";
+import { SpeedometerChart } from "./SpeedometerChart.js";
+import { StepProgress } from "./StepProgress.js";
+import { TallyChart } from "./TallyChart.js";
+import { TargetChart } from "./TargetChart.js";
+import { ThermometerChart } from "./ThermometerChart.js";
+import { TrafficLightChart } from "./TrafficLightChart.js";
+import { VuMeterChart } from "./VuMeterChart.js";
+// src/charts/indicators/index.ts
+var indicatorsCatalog = [
+	ActivityRings,
+	BatteryChart,
+	BulletChart,
+	DeltaIndicator,
+	GaugeChart,
+	HarveyBalls,
+	KpiTile,
+	LiquidFillGauge,
+	MeterChart,
+	ProgressRing,
+	RadialProgress,
+	RatingStars,
+	ScoreCard,
+	SegmentedGauge,
+	SpeedometerChart,
+	StepProgress,
+	TallyChart,
+	TargetChart,
+	ThermometerChart,
+	TrafficLightChart,
+	VuMeterChart
+];
+export { ActivityRings, BatteryChart, BatteryRim, BulletChart, BulletMeasure, BulletScale, BulletTarget, DeltaForm, DeltaIndicator, DeltaLayout, DeltaMode, DeltaSort, DialChart, GaugeChart, GaugeMarker, GaugeScale, GaugeSweep, HarveyBalls, HarveyForm, HarveyLayout, IndicatorCap, IndicatorChart, IndicatorStatus, KpiCompare, KpiDelta, KpiLayout, KpiSpark, KpiTile, LiquidFillGauge, LiquidLevel, LiquidShape, LiquidWave, MeterChart, MeterForm, MeterLabel, MeterZones, NeedleStyle, NumeralPlacement, ProgressRing, RadialLabel, RadialOrder, RadialProgress, RatingGlyph, RatingLayout, RatingPrecision, RatingStars, RingDirection, RingOverflow, RingStart, RingTrack, ScoreCard, ScoreDensity, ScoreGauge, ScoreSort, ScoreStatus, SegmentLit, SegmentMark, SegmentedGauge, SpeedometerChart, StepForm, StepLabels, StepProgress, TallyBundle, TallyChart, TallyLayout, TargetChart, TargetMark, TargetPlacement, TargetRingScale, TargetRingStyle, ThermometerBase, ThermometerChart, ThermometerScale, ThermometerSide, TickDensity, TrafficHousing, TrafficLayout, TrafficLightChart, VuMeterChart, VuResponse, indicatorsCatalog };

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 };

package/dist/charts/lifescience/OncoGlyph.js

@@ -0,0 +1,137 @@
+// src/charts/lifescience/OncoGlyph.ts
+/** Alteration classes an oncoprint draws. Declared in the order a cell's primary class is chosen. */
+var OncoAlteration = /* @__PURE__ */ function(OncoAlteration) {
+	OncoAlteration["Amplification"] = "amplification";
+	OncoAlteration["Deletion"] = "deep-deletion";
+	OncoAlteration["Fusion"] = "fusion";
+	OncoAlteration["Truncating"] = "truncating";
+	OncoAlteration["Splice"] = "splice";
+	OncoAlteration["Inframe"] = "inframe";
+	OncoAlteration["Missense"] = "missense";
+	OncoAlteration["Other"] = "other";
+	OncoAlteration["Gain"] = "gain";
+	OncoAlteration["Loss"] = "shallow-loss";
+	return OncoAlteration;
+}({});
+/** Cell layers, bottom to top. One event from each can share a cell. */
+var OncoLayer = /* @__PURE__ */ function(OncoLayer) {
+	OncoLayer["CopyNumber"] = "copy-number";
+	OncoLayer["Structural"] = "structural";
+	OncoLayer["Sequence"] = "sequence";
+	return OncoLayer;
+}({});
+var band = (top, bottom, left = 0, right = 1) => [
+	[left, top],
+	[right, top],
+	[right, bottom],
+	[left, bottom]
+];
+var SPECS = {
+	["amplification"]: {
+		label: "Amplification",
+		layer: "copy-number",
+		shape: [band(0, 1)],
+		polarity: 1
+	},
+	["deep-deletion"]: {
+		label: "Deep deletion",
+		layer: "copy-number",
+		shape: [band(0, .28), band(.72, 1)],
+		polarity: -1
+	},
+	["fusion"]: {
+		label: "Fusion",
+		layer: "structural",
+		shape: [[
+			[0, .1],
+			[1, .5],
+			[0, .9]
+		]]
+	},
+	["truncating"]: {
+		label: "Truncating",
+		layer: "sequence",
+		shape: [[
+			[0, .28],
+			[1, .28],
+			[.5, .72]
+		]]
+	},
+	["splice"]: {
+		label: "Splice",
+		layer: "sequence",
+		shape: [band(.12, .88, .28, .72)]
+	},
+	["inframe"]: {
+		label: "In-frame",
+		layer: "sequence",
+		shape: [[
+			[.5, .2],
+			[1, .5],
+			[.5, .8],
+			[0, .5]
+		]]
+	},
+	["missense"]: {
+		label: "Missense",
+		layer: "sequence",
+		shape: [band(.36, .64)]
+	},
+	["other"]: {
+		label: "Other",
+		layer: "sequence",
+		shape: [band(.2, .34, .15, .85), band(.66, .8, .15, .85)]
+	},
+	["gain"]: {
+		label: "Gain",
+		layer: "copy-number",
+		shape: [band(0, .5)],
+		polarity: .5
+	},
+	["shallow-loss"]: {
+		label: "Shallow loss",
+		layer: "copy-number",
+		shape: [band(.5, 1)],
+		polarity: -.5
+	}
+};
+/** cBioPortal OncoPrinter terms, MAF `Variant_Classification` values, Ensembl VEP consequences and common words. Tested in order. */
+var CLASSES = [
+	[/^(silent|synonymous|intron|igr|rna|[35]'?_?(utr|flank)|[35]_prime|upstream|downstream|intergenic|non_coding)/, null],
+	[/^(amp|amplification|amplified)$/, "amplification"],
+	[/^(homdel|deep_?deletion|deletion|homozygous_?deletion)$/, "deep-deletion"],
+	[/^gain$/, "gain"],
+	[/^(hetloss|shallow_?(deletion|loss)|loss)$/, "shallow-loss"],
+	[/fusion|rearrangement|translocation|structural/, "fusion"],
+	[/^in_?frame/, "inframe"],
+	[/^(trunc|nonsense|frame_?shift|stop_?gained|nonstop)/, "truncating"],
+	[/^splice/, "splice"],
+	[/^missense/, "missense"]
+];
+/** What each alteration class means and the silhouette it draws, so class survives without colour. */
+var OncoGlyph = class {
+	static order = Object.values(OncoAlteration);
+	static label(type) {
+		return SPECS[type].label;
+	}
+	static layer(type) {
+		return SPECS[type].layer;
+	}
+	/** Copy-number polarity from -1 to 1, or `undefined` for a class with identity rather than direction. */
+	static polarity(type) {
+		return SPECS[type].polarity;
+	}
+	/** The class of a cell's text, `null` for a blank or a variant that does not alter the protein, or `Other`. */
+	static classify(value) {
+		const word = String(value ?? "").trim().toLowerCase().replace(/[\s-]+/g, "_");
+		if (!word) return null;
+		const hit = CLASSES.find(([pattern]) => pattern.test(word));
+		return hit ? hit[1] : "other";
+	}
+	/** The glyph as path data, filling the box. */
+	static path(type, x, y, width, height) {
+		const round = (value) => +value.toFixed(2);
+		return SPECS[type].shape.map((polygon) => `M${polygon.map(([u, v]) => `${round(x + u * width)},${round(y + v * height)}`).join("L")}Z`).join("");
+	}
+};
+export { OncoAlteration, OncoGlyph, OncoLayer };