@mstone6969/graph 0.1.0 → 0.2.0

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

package/dist/charts/lifescience/OncoPrint.js

@@ -0,0 +1,373 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { ChartFamily, DataShape, Dimension, LegendPosition } from "../../core/enums.js";
+import { OncoAlteration, OncoGlyph } from "./OncoGlyph.js";
+import { FrameworkText } from "../frameworks/FrameworkText.js";
+import { OncoPrintMatrix, OncoSort } from "./OncoPrintMatrix.js";
+import { OncoPrintSamples } from "./OncoPrintSamples.js";
+// src/charts/lifescience/OncoPrint.ts
+/** Which marginal bars sit around the matrix. */
+var OncoTracks = /* @__PURE__ */ function(OncoTracks) {
+	OncoTracks["Both"] = "both-bars";
+	OncoTracks["Frequency"] = "gene-frequency";
+	OncoTracks["Burden"] = "sample-burden";
+	OncoTracks["None"] = "no-bars";
+	return OncoTracks;
+}({});
+/** What a marginal bar shows. */
+var OncoBars = /* @__PURE__ */ function(OncoBars) {
+	OncoBars["Stacked"] = "by-alteration";
+	OncoBars["Total"] = "total";
+	return OncoBars;
+}({});
+/** Whether samples with no alteration in these genes keep a column. */
+var OncoUnaltered = /* @__PURE__ */ function(OncoUnaltered) {
+	OncoUnaltered["Keep"] = "keep-unaltered";
+	OncoUnaltered["Hide"] = "hide-unaltered";
+	return OncoUnaltered;
+}({});
+var CHAR = 6.2;
+var PERCENT = 34;
+var LEGEND_ROW = 20;
+var SWATCH = {
+	width: 9,
+	height: 16
+};
+var GAP = 2;
+var clip = (text, room) => FrameworkText.fit(text, room, 11);
+var percent = (share) => share > 0 && share < .01 ? "<1%" : `${Math.round(share * 100)}%`;
+var plural = (count, noun) => `${count} ${noun}${count === 1 ? "" : "s"}`;
+/**
+* The cBioPortal gene-by-sample view (Gao et al. 2013, Sci Signal 6:pl1; Cerami et al. 2012, Cancer
+* Discov 2:401). Copy number, structural and sequence events layer in a cell, and every class has its
+* own silhouette. The default memo sort follows `memoSort` as used for MEMo (Ciriello et al. 2012,
+* Genome Res 22:398), which turns mutual exclusivity into a staircase.
+*/
+var OncoPrint = class OncoPrint extends Chart2D {
+	static meta = {
+		id: "oncoprint",
+		name: "OncoPrint",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Maps genes by samples with a glyph for each alteration type, to show recurrence and mutual exclusivity in a cohort. The sample cohort is synthetic.",
+		tags: [
+			"genomics",
+			"cancer",
+			"mutation",
+			"cbioportal",
+			"mutual exclusivity"
+		],
+		sample: (seed) => OncoPrintSamples.cohort(seed),
+		variants: {
+			sort: Object.values(OncoSort),
+			tracks: Object.values(OncoTracks),
+			bars: Object.values(OncoBars),
+			unaltered: Object.values(OncoUnaltered)
+		},
+		valid: (v) => v.tracks !== "no-bars" || v.bars === "by-alteration"
+	};
+	defaults() {
+		return {
+			sample: "sample",
+			gene: "gene",
+			alteration: "alteration",
+			sort: OncoSort.Memo,
+			tracks: "both-bars",
+			bars: "by-alteration",
+			unaltered: "keep-unaltered"
+		};
+	}
+	/** Glyphs need shape, which the shared swatch legend cannot draw, so the chart draws its own. */
+	legendItems() {
+		return [];
+	}
+	#matrix() {
+		const { data, sample, gene, alteration } = this.options;
+		return new OncoPrintMatrix(data, {
+			sample,
+			gene,
+			alteration
+		});
+	}
+	#order(matrix) {
+		return matrix.arrange(this.options.sort, this.options.unaltered === "hide-unaltered");
+	}
+	/** Seats classes in a fixed order, so each keeps its colour whatever the data holds. The rare `Other` takes the blue that deletions use. */
+	#seat(ctx) {
+		for (const type of [OncoAlteration.Other, ...OncoGlyph.order]) if (OncoGlyph.polarity(type) === void 0) ctx.palette.color(OncoGlyph.label(type));
+	}
+	#fill(ctx, type) {
+		const polarity = OncoGlyph.polarity(type);
+		return polarity !== void 0 ? ctx.palette.diverging(polarity) : ctx.palette.color(OncoGlyph.label(type));
+	}
+	#legend(types, width) {
+		if (this.legendPosition === LegendPosition.None) return [];
+		let x = 0, y = 0;
+		return types.map((type) => {
+			const text = OncoGlyph.label(type), cost = SWATCH.width + 5 + text.length * CHAR + 14;
+			if (x && x + cost > width) {
+				x = 0;
+				y += LEGEND_ROW;
+			}
+			const at = {
+				type,
+				x,
+				y,
+				text
+			};
+			x += cost;
+			return at;
+		});
+	}
+	#layout(ctx, { genes, samples }, legendHeight) {
+		const { width, height } = ctx.plot, { tracks } = this.options;
+		const frequency = tracks === "both-bars" || tracks === "gene-frequency";
+		const burden = tracks === "both-bars" || tracks === "sample-burden";
+		const longest = Math.max(...genes.map((gene) => FrameworkText.width(gene, 11)));
+		const labels = Math.min(longest, 96, width * .2) + 6;
+		const barWidth = frequency ? Math.max(40, Math.min(96, width * .15)) : 0;
+		const bandHeight = burden ? Math.max(28, Math.min(56, height * .16)) : frequency ? 16 : 0;
+		const x = labels + PERCENT + GAP, y = bandHeight + (bandHeight ? 4 : 0);
+		const matrixWidth = Math.max(10, width - x - (barWidth ? barWidth + 10 : 0));
+		const matrixHeight = Math.max(10, height - y - legendHeight);
+		return {
+			matrix: {
+				x,
+				y,
+				width: matrixWidth,
+				height: matrixHeight
+			},
+			labelX: labels - 6,
+			percentX: x - 6,
+			barX: x + matrixWidth + 10,
+			barWidth,
+			bandHeight,
+			legendY: y + matrixHeight + 10,
+			rowHeight: matrixHeight / genes.length,
+			columnWidth: matrixWidth / samples.length
+		};
+	}
+	/** Gaps close up as cells narrow, since a 2px gap would leave no cell. */
+	static #inset(step) {
+		return step >= 6 ? GAP : step >= 3 ? 1 : 0;
+	}
+	#cells(ctx, matrix, { genes, samples }, layout) {
+		const { matrix: box, rowHeight, columnWidth } = layout;
+		const across = OncoPrint.#inset(columnWidth), down = OncoPrint.#inset(rowHeight);
+		const left = (i) => box.x + i * columnWidth + across / 2, top = (j) => box.y + j * rowHeight + down / 2;
+		const width = Math.max(.5, columnWidth - across), height = Math.max(.5, rowHeight - down);
+		const tracks = genes.map((gene, j) => ({
+			gene,
+			d: samples.map((_, i) => `M${left(i).toFixed(2)},${top(j).toFixed(2)}h${width.toFixed(2)}v${height.toFixed(2)}h${(-width).toFixed(2)}z`).join("")
+		}));
+		const rows = ctx.marks("tracks", "path", tracks, (track) => track.gene).attr("fill", ctx.theme.grid).style("pointer-events", "none");
+		ctx.set(rows, { d: (track) => track.d });
+		const glyphs = genes.flatMap((gene, j) => samples.flatMap((sample, i) => {
+			const cell = matrix.cell(gene, sample);
+			return cell ? OncoPrintMatrix.layers(cell).map(({ type }) => ({
+				key: `${gene}|${sample}|${OncoGlyph.layer(type)}`,
+				cell,
+				type,
+				d: OncoGlyph.path(type, left(i), top(j), width, height)
+			})) : [];
+		}));
+		const marks = ctx.marks("glyphs", "path", glyphs, (glyph) => glyph.key).attr("fill", (glyph) => this.#fill(ctx, glyph.type));
+		ctx.set(marks, {
+			d: (glyph) => glyph.d,
+			"fill-opacity": 1
+		}, { "fill-opacity": 0 });
+		ctx.hover(marks, ({ cell, type }) => ({
+			title: `${cell.gene}, ${cell.sample}`,
+			color: this.#fill(ctx, type),
+			rows: cell.events.map((event) => [OncoGlyph.label(event.type), event.text])
+		}));
+	}
+	/** Bar length runs from zero, so a stack's far end is the exact total; gaps come out of the inner ends. */
+	#segments(subject, cells, draw, unit) {
+		const hits = cells.filter((cell) => !!cell), total = hits.length;
+		if (!total) return [];
+		const counts = this.options.bars === "total" ? [[null, total]] : OncoGlyph.order.map((type) => [type, hits.filter((cell) => cell.primary === type).length]).filter(([, count]) => count);
+		let run = 0;
+		return counts.map(([type, count], i) => {
+			const from = run;
+			run += count;
+			const lead = i ? Math.min(GAP, (unit(run) - unit(from)) / 3) : 0;
+			return {
+				key: `${subject}|${type ?? "all"}`,
+				subject,
+				type,
+				count,
+				total,
+				d: draw(unit(from) + lead, unit(run), i === counts.length - 1)
+			};
+		});
+	}
+	#bars(ctx, name, segments, tip) {
+		const fill = (segment) => segment.type ? this.#fill(ctx, segment.type) : ctx.theme.inkMuted;
+		const marks = ctx.marks(name, "path", segments, (segment) => segment.key).attr("fill", fill);
+		ctx.set(marks, {
+			d: (segment) => segment.d,
+			"fill-opacity": 1
+		}, { "fill-opacity": 0 });
+		ctx.hover(marks, (segment) => ({
+			title: tip(segment),
+			color: fill(segment),
+			rows: segment.type ? [[OncoGlyph.label(segment.type), segment.count]] : [["Total", segment.total]]
+		}));
+	}
+	#frequencyBars(ctx, matrix, { genes }, layout) {
+		const { barX, barWidth, matrix: box, rowHeight } = layout;
+		const peak = Math.max(1, ...genes.map((gene) => matrix.altered(gene)));
+		const shown = barWidth ? genes : [];
+		const thick = Math.min(14, Math.max(1, rowHeight - OncoPrint.#inset(rowHeight) - 2));
+		const bars = shown.flatMap((gene, j) => {
+			const y = box.y + (j + .5) * rowHeight - thick / 2, r = Math.min(4, thick / 2);
+			const path = (from, to, end) => {
+				const a = barX + from, b = barX + to, bend = end ? Math.min(r, b - a) : 0;
+				return `M${a.toFixed(2)},${y.toFixed(2)}H${(b - bend).toFixed(2)}Q${b.toFixed(2)},${y.toFixed(2)} ${b.toFixed(2)},${(y + bend).toFixed(2)}V${(y + thick - bend).toFixed(2)}Q${b.toFixed(2)},${(y + thick).toFixed(2)} ${(b - bend).toFixed(2)},${(y + thick).toFixed(2)}H${a.toFixed(2)}Z`;
+			};
+			return this.#segments(gene, matrix.samples.map((sample) => matrix.cell(gene, sample)), path, (count) => count / peak * barWidth);
+		});
+		this.#bars(ctx, "gene-bars", bars, (segment) => `${segment.subject}: ${segment.total} of ${plural(matrix.samples.length, "sample")}`);
+	}
+	#burdenBars(ctx, matrix, { genes, samples }, layout) {
+		const { matrix: box, bandHeight, columnWidth } = layout;
+		const { tracks } = this.options;
+		const shown = tracks === "both-bars" || tracks === "sample-burden" ? samples : [];
+		const peak = Math.max(1, ...samples.map((sample) => matrix.burden(sample)));
+		const across = OncoPrint.#inset(columnWidth), thick = Math.max(.5, columnWidth - across);
+		const bars = shown.flatMap((sample, i) => {
+			const x = box.x + i * columnWidth + across / 2, r = Math.min(4, thick / 2), floor = bandHeight;
+			const path = (from, to, end) => {
+				const a = floor - from, b = floor - to, bend = end ? Math.min(r, a - b) : 0;
+				return `M${x.toFixed(2)},${a.toFixed(2)}V${(b + bend).toFixed(2)}Q${x.toFixed(2)},${b.toFixed(2)} ${(x + bend).toFixed(2)},${b.toFixed(2)}H${(x + thick - bend).toFixed(2)}Q${(x + thick).toFixed(2)},${b.toFixed(2)} ${(x + thick).toFixed(2)},${(b + bend).toFixed(2)}V${a.toFixed(2)}Z`;
+			};
+			return this.#segments(sample, genes.map((gene) => matrix.cell(gene, sample)), path, (count) => count / peak * bandHeight);
+		});
+		this.#bars(ctx, "burden-bars", bars, (segment) => `${segment.subject}: ${plural(segment.total, "altered gene")}`);
+	}
+	#captions(ctx, matrix, { genes, samples }, layout) {
+		const { matrix: box, rowHeight, labelX, percentX, barX, barWidth, bandHeight } = layout;
+		const { tracks } = this.options;
+		const stride = Math.ceil(12 / rowHeight);
+		const named = genes.flatMap((gene, j) => {
+			if (j % stride) return [];
+			const y = box.y + (j + .5) * rowHeight + 4;
+			return [{
+				key: `gene-${gene}`,
+				text: clip(gene, labelX),
+				x: labelX,
+				y,
+				anchor: "end",
+				tone: "ink"
+			}, {
+				key: `share-${gene}`,
+				text: percent(matrix.frequency(gene)),
+				x: percentX,
+				y,
+				anchor: "end"
+			}];
+		});
+		const burden = tracks === "both-bars" || tracks === "sample-burden";
+		const peak = Math.max(1, ...samples.map((sample) => matrix.burden(sample)));
+		const scale = burden ? [
+			{
+				key: "burden-peak",
+				text: `${peak}`,
+				x: box.x - 6,
+				y: 10,
+				anchor: "end",
+				tone: "muted"
+			},
+			{
+				key: "burden-zero",
+				text: "0",
+				x: box.x - 6,
+				y: bandHeight,
+				anchor: "end",
+				tone: "muted"
+			},
+			{
+				key: "burden-title",
+				text: clip("Burden", box.x - 26),
+				x: box.x - 22,
+				y: bandHeight / 2 + 4,
+				anchor: "end"
+			}
+		] : [];
+		const altered = Math.max(0, ...genes.map((gene) => matrix.altered(gene)));
+		const side = barWidth ? [
+			{
+				key: "gene-peak",
+				text: `${altered}`,
+				x: barX + barWidth,
+				y: bandHeight - 2,
+				anchor: "end",
+				tone: "muted"
+			},
+			{
+				key: "gene-zero",
+				text: "0",
+				x: barX,
+				y: bandHeight - 2,
+				anchor: "start",
+				tone: "muted"
+			},
+			...barWidth >= 84 ? [{
+				key: "gene-title",
+				text: "Samples",
+				x: barX + barWidth / 2,
+				y: bandHeight - 2,
+				anchor: "middle"
+			}] : []
+		] : [];
+		const texts = ctx.marks("captions", "text", [
+			...named,
+			...scale,
+			...side
+		], (caption) => caption.key);
+		ctx.text(texts).attr("text-anchor", (d) => d.anchor).attr("x", (d) => d.x).attr("y", (d) => d.y).text((d) => d.text).attr("fill", (d) => ({
+			ink: ctx.theme.ink,
+			secondary: ctx.theme.inkSecondary,
+			muted: ctx.theme.inkMuted
+		})[d.tone ?? "secondary"]).style("pointer-events", "none");
+		const rail = ctx.marks("rail", "line", barWidth ? [0] : []).attr("stroke", ctx.theme.axis).attr("stroke-width", 1);
+		ctx.set(rail, {
+			x1: barX,
+			x2: barX,
+			y1: box.y,
+			y2: box.y + box.height
+		});
+	}
+	#drawLegend(ctx, swatches, { legendY }) {
+		const backs = ctx.marks("legend-cells", "rect", swatches, (d) => d.type).attr("fill", ctx.theme.grid);
+		ctx.set(backs, {
+			x: (d) => d.x,
+			y: (d) => legendY + d.y,
+			width: SWATCH.width,
+			height: SWATCH.height
+		});
+		const marks = ctx.marks("legend-glyphs", "path", swatches, (d) => d.type).attr("fill", (d) => this.#fill(ctx, d.type));
+		ctx.set(marks, { d: (d) => OncoGlyph.path(d.type, d.x, legendY + d.y, SWATCH.width, SWATCH.height) });
+		const names = ctx.marks("legend-names", "text", swatches, (d) => d.type);
+		ctx.text(names).attr("x", (d) => d.x + SWATCH.width + 5).attr("y", (d) => legendY + d.y + 12).text((d) => d.text);
+	}
+	draw(ctx) {
+		this.#seat(ctx);
+		const matrix = this.#matrix(), order = this.#order(matrix);
+		if (!order.genes.length || !order.samples.length) {
+			ctx.root.selectAll("*").remove();
+			return;
+		}
+		const present = OncoGlyph.order.filter((type) => order.genes.some((gene) => order.samples.some((sample) => matrix.cell(gene, sample)?.events.some((event) => event.type === type))));
+		const swatches = this.#legend(present, ctx.plot.width);
+		const legendHeight = swatches.length ? swatches.at(-1).y + LEGEND_ROW + 6 : 0;
+		const layout = this.#layout(ctx, order, legendHeight);
+		this.#cells(ctx, matrix, order, layout);
+		this.#frequencyBars(ctx, matrix, order, layout);
+		this.#burdenBars(ctx, matrix, order, layout);
+		this.#captions(ctx, matrix, order, layout);
+		this.#drawLegend(ctx, swatches, layout);
+	}
+};
+export { OncoBars, OncoPrint, OncoTracks, OncoUnaltered };

package/dist/charts/lifescience/OncoPrintMatrix.js

@@ -0,0 +1,107 @@
+import { OncoGlyph, OncoLayer } from "./OncoGlyph.js";
+// src/charts/lifescience/OncoPrintMatrix.ts
+/** How genes and samples are ordered. */
+var OncoSort = /* @__PURE__ */ function(OncoSort) {
+	/** Genes by frequency, then samples lexicographically on those genes, for the mutual-exclusivity staircase. */
+	OncoSort["Memo"] = "memo";
+	/** Genes by frequency, then samples by how many genes are altered. */
+	OncoSort["Burden"] = "burden";
+	/** Both as first seen in the rows. */
+	OncoSort["Input"] = "input";
+	return OncoSort;
+}({});
+var name = (cell) => cell === null || cell === void 0 || cell === "" ? null : String(cell);
+var rank = (type) => OncoGlyph.order.indexOf(type);
+/** Long-form alteration rows as a gene by sample matrix: frequencies, burden, and the orderings. */
+var OncoPrintMatrix = class {
+	genes;
+	samples;
+	#cells = /* @__PURE__ */ new Map();
+	/** A row with a blank alteration, or a blank gene, only records that its sample was profiled. */
+	constructor(rows, { sample, gene, alteration }) {
+		const genes = /* @__PURE__ */ new Set(), samples = /* @__PURE__ */ new Set();
+		for (const row of Array.isArray(rows) ? rows : []) {
+			if (row === null || typeof row !== "object") continue;
+			const s = name(row[sample]), g = name(row[gene]);
+			if (s) samples.add(s);
+			if (g) genes.add(g);
+			const type = OncoGlyph.classify(row[alteration]);
+			if (s && g && type) this.#record(g, s, {
+				type,
+				text: String(row[alteration])
+			});
+		}
+		this.genes = [...genes];
+		this.samples = [...samples];
+	}
+	#record(gene, sample, event) {
+		let row = this.#cells.get(gene);
+		if (!row) this.#cells.set(gene, row = /* @__PURE__ */ new Map());
+		const cell = row.get(sample);
+		if (!cell) {
+			row.set(sample, {
+				gene,
+				sample,
+				events: [event],
+				primary: event.type
+			});
+			return;
+		}
+		if (cell.events.some((other) => other.type === event.type && other.text === event.text)) return;
+		cell.events.push(event);
+		if (rank(event.type) < rank(cell.primary)) cell.primary = event.type;
+	}
+	cell(gene, sample) {
+		return this.#cells.get(gene)?.get(sample);
+	}
+	/** Samples with any alteration in `gene`. */
+	altered(gene) {
+		return this.#cells.get(gene)?.size ?? 0;
+	}
+	/** Genes altered in `sample`, among those plotted. */
+	burden(sample) {
+		return this.genes.reduce((sum, gene) => sum + (this.cell(gene, sample) ? 1 : 0), 0);
+	}
+	/** Share of the whole cohort, shown or not, with `gene` altered. */
+	frequency(gene) {
+		return this.samples.length ? this.altered(gene) / this.samples.length : 0;
+	}
+	/** The strongest event of each layer, bottom layer first: what a cell draws. */
+	static layers(cell) {
+		return Object.values(OncoLayer).flatMap((layer) => {
+			const inLayer = cell.events.filter((event) => OncoGlyph.layer(event.type) === layer);
+			return inLayer.length ? [inLayer.reduce((best, event) => rank(event.type) < rank(best.type) ? event : best)] : [];
+		});
+	}
+	/** Samples are ordered, and may be hidden, but `frequency` always counts the whole cohort. */
+	arrange(sort, hideUnaltered = false) {
+		const byFrequency = [...this.genes].sort((a, b) => this.altered(b) - this.altered(a));
+		const shown = hideUnaltered ? this.samples.filter((sample) => this.burden(sample) > 0) : [...this.samples];
+		if (sort === "input") return {
+			genes: [...this.genes],
+			samples: shown
+		};
+		if (sort === "burden") return {
+			genes: byFrequency,
+			samples: shown.sort((a, b) => this.burden(b) - this.burden(a))
+		};
+		return {
+			genes: byFrequency,
+			samples: this.#memo(byFrequency, shown)
+		};
+	}
+	/**
+	* MEMo-style sort: the binary score Σ 2^(n-i) over genes in frequency order, decreasing. Comparing
+	* gene by gene gives the same order and, unlike the score, stays exact past 53 genes.
+	*/
+	#memo(genes, samples) {
+		return samples.sort((a, b) => {
+			for (const gene of genes) {
+				const left = this.cell(gene, a) ? 1 : 0, right = this.cell(gene, b) ? 1 : 0;
+				if (left !== right) return right - left;
+			}
+			return 0;
+		});
+	}
+};
+export { OncoPrintMatrix, OncoSort };