@mstone6969/graph 0.1.0 → 0.2.0

package/dist/charts/lifescience/OncoPrintSamples.js

@@ -0,0 +1,142 @@
+import { SampleData } from "../../data/SampleData.js";
+import { StatMath } from "../statistics/StatMath.js";
+// src/charts/lifescience/OncoPrintSamples.ts
+/** Each list is one pathway: a sample takes at most one gene from it, so the staircase is designed in. */
+var PATHWAYS = [
+	[
+		[
+			"SYN1",
+			.3,
+			[
+				"Missense",
+				"Missense",
+				"Amplification"
+			]
+		],
+		[
+			"SYN2",
+			.16,
+			[
+				"Missense",
+				"Amplification",
+				"In-frame"
+			]
+		],
+		[
+			"SYN3",
+			.08,
+			["Missense"]
+		],
+		[
+			"SYN4",
+			.05,
+			["Fusion"]
+		],
+		[
+			"SYN5",
+			.05,
+			["Splice", "Amplification"]
+		]
+	],
+	[
+		[
+			"SYN6",
+			.2,
+			["Deep deletion", "Truncating"]
+		],
+		[
+			"SYN7",
+			.08,
+			["Amplification", "Gain"]
+		],
+		[
+			"SYN8",
+			.07,
+			["Truncating", "Deep deletion"]
+		]
+	],
+	[[
+		"SYN9",
+		.15,
+		["Missense", "Amplification"]
+	], [
+		"SYN10",
+		.1,
+		[
+			"Deep deletion",
+			"Truncating",
+			"Shallow loss"
+		]
+	]],
+	[[
+		"SYN11",
+		.14,
+		["Truncating", "Splice"]
+	], [
+		"SYN12",
+		.1,
+		["Missense", "Truncating"]
+	]]
+];
+var TP53 = [
+	"SYN13",
+	.55,
+	[
+		"Missense",
+		"Missense",
+		"Truncating",
+		"Splice"
+	]
+];
+var MYC = [
+	"SYN14",
+	.12,
+	["Amplification", "Gain"]
+];
+var QUIET = .1;
+/** An invented cohort, not a measurement: placeholder `SYN` gene names and invented frequencies. */
+var OncoPrintSamples = class {
+	/** `{ sample, gene, alteration, source }`, long form. A row with no gene marks a profiled sample with nothing to show. */
+	static cohort(seed, samples = 64) {
+		const draws = SampleData.distribution(seed, samples * 20, 1).map((row) => StatMath.normalCdf((row.value - 40) / 8));
+		let next = 0;
+		const u = () => draws[next++ % draws.length];
+		const rows = [
+			TP53,
+			MYC,
+			...PATHWAYS.flat()
+		].map(([gene]) => ({
+			sample: null,
+			gene,
+			alteration: null,
+			source: "synthetic"
+		}));
+		for (let i = 0; i < samples; i++) {
+			const sample = `SYN-${String(i + 1).padStart(3, "0")}`;
+			const hit = ([gene, , kinds]) => {
+				rows.push({
+					sample,
+					gene,
+					alteration: kinds[Math.floor(u() * kinds.length)],
+					source: "synthetic"
+				});
+			};
+			rows.push({
+				sample,
+				gene: null,
+				alteration: null,
+				source: "synthetic"
+			});
+			if (u() < QUIET) continue;
+			if (u() < TP53[1]) hit(TP53);
+			if (u() < MYC[1]) hit(MYC);
+			for (const pathway of PATHWAYS) {
+				let pick = u();
+				const chosen = pathway.find(([, share]) => (pick -= share) < 0);
+				if (chosen) hit(chosen);
+			}
+		}
+		return rows;
+	}
+};
+export { OncoPrintSamples };

package/dist/charts/lifescience/PedigreeChart.js

@@ -0,0 +1,306 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { PedigreeCaption, PedigreeCarrierMark, PedigreeSex } from "./pedigreeEnums.js";
+import { PedigreeLayout } from "./PedigreeLayout.js";
+import { PedigreeRows } from "./PedigreeRows.js";
+import { PedigreeSamples } from "./PedigreeSamples.js";
+import { PedigreeSymbol } from "./PedigreeSymbol.js";
+// src/charts/lifescience/PedigreeChart.ts
+var NUMERALS = [
+	[1e3, "M"],
+	[900, "CM"],
+	[500, "D"],
+	[400, "CD"],
+	[100, "C"],
+	[90, "XC"],
+	[50, "L"],
+	[40, "XL"],
+	[10, "X"],
+	[9, "IX"],
+	[5, "V"],
+	[4, "IV"],
+	[1, "I"]
+];
+var MAX_SIZE = 30;
+var MIN_SIZE = 8;
+var SLOT_SHARE = .66;
+var CHAR = 6.2;
+var NAME_CHAR = 5.6;
+var LINE = 2;
+var THIN_LINE = 1;
+var LINE_SHARE = 7;
+var CONSANGUINITY_GAP = 2.5;
+var LANE_STEP = 3;
+var LANE_ROOM = 8;
+var NUMBER_ROOM = 13;
+var KEY_ROW = 19;
+var KEY_MARK = 11;
+var OVER_LIFT = 7;
+var ARROW_ROOM = 34;
+var LETTER_DROP = 12;
+var LETTER_HALF = 5;
+var SEX_LABELS = {
+	[PedigreeSex.Male]: "Male",
+	[PedigreeSex.Female]: "Female",
+	[PedigreeSex.Unknown]: "Sex unknown"
+};
+/**
+* Trace how a trait runs through a family, in the standard human pedigree nomenclature of Bennett et al.
+* (2008) J Genet Couns 17:424-433: square male, circle female, diamond sex unknown, filled affected,
+* dot carrier, slash deceased, arrow and P proband, double line consanguinity. Generations are numbered
+* in Roman numerals and people left to right within each. Unions of relatives are detected from shared
+* ancestors. Parents, siblings in birth order and marriages come from `father`, `mother` and `partner`.
+*/
+var PedigreeChart = class PedigreeChart extends Chart2D {
+	static meta = {
+		id: "pedigree",
+		name: "Pedigree chart",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Draws a family tree in standard genetics notation, showing who is affected, a carrier or deceased across numbered generations.",
+		tags: [
+			"genetics",
+			"inheritance",
+			"family",
+			"nsgc",
+			"proband",
+			"consanguinity"
+		],
+		sample: (seed) => PedigreeSamples.recessive(seed),
+		variants: {
+			carrierMark: Object.values(PedigreeCarrierMark),
+			caption: Object.values(PedigreeCaption),
+			showKey: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			id: "id",
+			father: "father",
+			mother: "mother",
+			sex: "sex",
+			affected: "affected",
+			carrier: "carrier",
+			deceased: "deceased",
+			proband: "proband",
+			partner: "partner",
+			consanguineous: "consanguineous",
+			label: "label",
+			carrierMark: PedigreeCarrierMark.Dot,
+			caption: PedigreeCaption.Number,
+			showKey: true
+		};
+	}
+	plotMargin() {
+		return {
+			top: 8,
+			right: 12,
+			bottom: 8,
+			left: 12
+		};
+	}
+	static roman(value) {
+		let left = value, out = "";
+		for (const [size, glyph] of NUMERALS) while (left >= size) {
+			out += glyph;
+			left -= size;
+		}
+		return out;
+	}
+	static #tag(item) {
+		return `${PedigreeChart.roman(item.generation + 1)}-${item.number}`;
+	}
+	#frame(ctx, layout, keyHeight) {
+		const { width, height } = ctx.plot, generations = layout.generations || 1, { caption } = this.options;
+		const captionRoom = caption === PedigreeCaption.None ? 0 : caption === PedigreeCaption.Number ? NUMBER_ROOM : 26;
+		const gutter = Math.max(24, PedigreeChart.roman(generations).length * 7.4 + 12);
+		const slot = (width - gutter) / (layout.extent + 1);
+		const room = height - keyHeight;
+		const arrowDrop = layout.people.some((item) => item.person.proband) ? ARROW_ROOM : 0;
+		const across = Math.max(slot * SLOT_SHARE, Math.min(MIN_SIZE, slot * .85));
+		const lanes = Math.max(0, ...layout.lanes);
+		const down = (room - 8 - arrowDrop + captionRoom) / generations - captionRoom - LANE_ROOM - LANE_STEP * Math.max(0, lanes - 1);
+		const size = Math.max(4, Math.min(MAX_SIZE, across, down));
+		const top = size * .62 + 5;
+		const floor = room - 4 - size / 2 - Math.max(captionRoom, arrowDrop);
+		const step = generations > 1 ? Math.max(0, floor - top) / (generations - 1) : 0;
+		const y = (generation) => top + generation * step;
+		const laneY = (generation, lane) => {
+			const under = y(generation + 1) - size * .62 - 3, gap = under - (y(generation) + size / 2 + captionRoom);
+			return under - lane * Math.min(LANE_STEP, gap / Math.max(1, layout.lanes[generation] ?? 1));
+		};
+		return {
+			size,
+			line: Math.max(THIN_LINE, Math.min(LINE, size / LINE_SHARE)),
+			x: (at) => gutter + slot * (at + .5),
+			y,
+			laneY,
+			captionRoom,
+			gutter,
+			keyTop: room
+		};
+	}
+	#couplePath(couple, { x, y, size }) {
+		const from = x(couple.left.x), to = x(couple.right.x), at = y(couple.left.generation);
+		if (!couple.adjacent) {
+			const over = at - size / 2 - OVER_LIFT + (couple.consanguineous ? CONSANGUINITY_GAP : 0);
+			const span = (lift) => `M${from} ${at - size / 2}V${over + lift}H${to}V${at - size / 2}`;
+			return couple.consanguineous ? span(-2.5) + span(CONSANGUINITY_GAP) : span(0);
+		}
+		return couple.consanguineous ? `M${from} ${at - CONSANGUINITY_GAP}H${to}M${from} ${at + CONSANGUINITY_GAP}H${to}` : `M${from} ${at}H${to}`;
+	}
+	#sibshipPath(sibship, frame, couples) {
+		const { x, y, laneY, size } = frame;
+		const lane = laneY(sibship.generation, sibship.lane), parentRow = sibship.parents[0].generation;
+		const couple = couples.get(sibship.key);
+		const start = sibship.parents.length === 1 ? y(parentRow) + PedigreeSymbol.reach(sibship.parents[0].person.sex, size) : couple && !couple.adjacent ? y(parentRow) - size / 2 - OVER_LIFT : y(parentRow) + (couple?.consanguineous ? CONSANGUINITY_GAP : 0);
+		const drops = sibship.children.map((child) => `M${x(child.x)} ${lane}V${y(child.generation) - PedigreeSymbol.reach(child.person.sex, size)}`).join("");
+		return `M${x(sibship.drop)} ${start}V${lane}M${x(sibship.from)} ${lane}H${x(sibship.to)}${drops}`;
+	}
+	#drawLines(ctx, layout, frame) {
+		const line = (selection) => selection.attr("fill", "none").attr("stroke", ctx.theme.inkSecondary).attr("stroke-width", frame.line);
+		const known = new Map(layout.couples.map((couple) => [couple.key, couple]));
+		ctx.set(line(ctx.marks("descent-lines", "path", layout.sibships, (d) => d.key)), { d: (d) => this.#sibshipPath(d, frame, known) });
+		ctx.set(line(ctx.marks("union-lines", "path", layout.couples, (d) => d.key)), { d: (d) => this.#couplePath(d, frame) });
+	}
+	#drawSymbols(ctx, people, frame) {
+		const { x, y, size, line } = frame, { ink, surface } = ctx.theme;
+		const dotted = this.options.carrierMark === PedigreeCarrierMark.Dot;
+		const carriers = people.filter((item) => item.person.carrier && !item.person.affected);
+		const shapes = ctx.marks("symbols", "path", people, (d) => d.person.key).attr("fill", (d) => d.person.affected ? ink : surface).attr("stroke", ink).attr("stroke-width", line);
+		ctx.set(shapes, {
+			d: (d) => PedigreeSymbol.outline(d.person.sex, x(d.x), y(d.generation), size),
+			"fill-opacity": 1
+		}, { "fill-opacity": 0 }, 12);
+		ctx.hover(shapes, (d) => ({
+			title: d.person.name,
+			rows: [
+				["Individual", PedigreeChart.#tag(d)],
+				["Sex", SEX_LABELS[d.person.sex]],
+				["Status", [
+					d.person.affected ? "Affected" : d.person.carrier ? "Carrier" : "Unaffected",
+					d.person.deceased && "deceased",
+					d.person.proband && "proband"
+				].filter(Boolean).join(", ")]
+			]
+		}));
+		const halves = ctx.marks("carrier-halves", "path", dotted ? [] : carriers, (d) => d.person.key).attr("fill", ink).attr("pointer-events", "none");
+		ctx.set(halves, { d: (d) => PedigreeSymbol.leftHalf(d.person.sex, x(d.x), y(d.generation), size) });
+		const dots = ctx.marks("carrier-dots", "circle", dotted ? carriers : [], (d) => d.person.key).attr("fill", ink).attr("pointer-events", "none");
+		ctx.set(dots, {
+			cx: (d) => x(d.x),
+			cy: (d) => y(d.generation),
+			r: Math.max(1.5, size * .14)
+		});
+		const slashes = ctx.marks("slashes", "line", people.filter((item) => item.person.deceased), (d) => d.person.key).attr("stroke", ink).attr("stroke-width", line).attr("pointer-events", "none");
+		const slash = (d) => PedigreeSymbol.slash(x(d.x), y(d.generation), size);
+		ctx.set(slashes, {
+			x1: (d) => slash(d).x1,
+			y1: (d) => slash(d).y1,
+			x2: (d) => slash(d).x2,
+			y2: (d) => slash(d).y2
+		});
+	}
+	#drawProbands(ctx, people, { x, y, size, line }) {
+		const probands = people.filter((item) => item.person.proband);
+		const arrow = (d) => PedigreeSymbol.arrow(x(d.x), y(d.generation), size);
+		const shafts = ctx.marks("proband-shafts", "path", probands, (d) => d.person.key).attr("fill", "none").attr("stroke", ctx.theme.ink).attr("stroke-width", line).attr("pointer-events", "none");
+		ctx.set(shafts, { d: (d) => arrow(d).shaft });
+		const heads = ctx.marks("proband-heads", "path", probands, (d) => d.person.key).attr("fill", ctx.theme.ink).attr("pointer-events", "none");
+		ctx.set(heads, { d: (d) => arrow(d).head });
+		ctx.text(ctx.marks("proband-letters", "text", probands, (d) => d.person.key), 11, "ink").attr("font-weight", 600).attr("text-anchor", "middle").attr("pointer-events", "none").attr("stroke", ctx.theme.surface).attr("stroke-width", 3).attr("paint-order", "stroke").attr("x", (d) => arrow(d).tail[0]).attr("y", (d) => arrow(d).tail[1] + LETTER_DROP).text("P");
+	}
+	#drawCaptions(ctx, people, layout, { x, y, size, captionRoom }) {
+		const { caption } = this.options;
+		const slot = layout.extent > 0 ? Math.abs(x(1) - x(0)) : ctx.plot.width;
+		const fit = (text) => {
+			const most = Math.floor((slot - 4) / NAME_CHAR);
+			if (most < 2) return "";
+			return text.length > most ? `${text.slice(0, most - 1)}…` : text;
+		};
+		const solo = new Set(layout.sibships.filter((item) => item.parents.length === 1).map((item) => item.parents[0].person.key));
+		const sideways = (d) => solo.has(d.person.key) ? 4 : 0;
+		const under = (d) => y(d.generation) + PedigreeSymbol.reach(d.person.sex, size);
+		const shown = captionRoom ? people.filter(() => slot >= 12) : [];
+		ctx.text(ctx.marks("numbers", "text", shown, (d) => d.person.key), 10.5, "secondary").attr("pointer-events", "none").attr("text-anchor", (d) => sideways(d) ? "start" : "middle").attr("x", (d) => x(d.x) + sideways(d)).attr("y", (d) => under(d) + 13).text((d) => d.number);
+		const letters = people.filter((d) => d.person.proband).map((d) => PedigreeSymbol.arrow(x(d.x), y(d.generation), size).tail);
+		const clear = (d) => {
+			const half = fit(d.person.name).length * NAME_CHAR / 2 + LETTER_HALF, base = under(d) + 25;
+			return !letters.some(([at, top]) => Math.abs(at - x(d.x)) < half && top + LETTER_DROP + 2 > base - 9 && top < base);
+		};
+		const names = caption === PedigreeCaption.NumberAndName ? shown.filter((d) => fit(d.person.name) && clear(d)) : [];
+		ctx.text(ctx.marks("names", "text", names, (d) => d.person.key), 10, "muted").attr("pointer-events", "none").attr("text-anchor", (d) => sideways(d) ? "start" : "middle").attr("x", (d) => x(d.x) + sideways(d)).attr("y", (d) => under(d) + 25).text((d) => fit(d.person.name));
+	}
+	#drawGenerations(ctx, layout, { y }) {
+		const rows = Array.from({ length: layout.generations }, (_, i) => i);
+		ctx.text(ctx.marks("generations", "text", rows, (d) => d), 12, "ink").attr("font-weight", 600).attr("dy", "0.35em").attr("x", 0).attr("y", (d) => y(d)).text((d) => PedigreeChart.roman(d + 1));
+	}
+	#keyEntries(layout) {
+		const m = KEY_MARK, c = m / 2, { people, couples } = layout, some = (test) => people.some(test);
+		const square = PedigreeSymbol.outline(PedigreeSex.Male, c, 0, m);
+		const entry = (label, shown, stroke, fill = "", dot) => shown ? [{
+			label,
+			stroke,
+			fill,
+			dot
+		}] : [];
+		const carrier = this.options.carrierMark === PedigreeCarrierMark.Dot;
+		const slash = PedigreeSymbol.slash(c, 0, m);
+		const arrow = PedigreeSymbol.arrow(11.5, -7, 7);
+		return [
+			...entry(SEX_LABELS[PedigreeSex.Male], some((d) => d.person.sex === PedigreeSex.Male), square),
+			...entry(SEX_LABELS[PedigreeSex.Female], some((d) => d.person.sex === PedigreeSex.Female), PedigreeSymbol.outline(PedigreeSex.Female, c, 0, m)),
+			...entry(SEX_LABELS[PedigreeSex.Unknown], some((d) => d.person.sex === PedigreeSex.Unknown), PedigreeSymbol.outline(PedigreeSex.Unknown, c, 0, m * .85)),
+			...entry("Affected", some((d) => d.person.affected), square, square),
+			...entry("Carrier", some((d) => d.person.carrier && !d.person.affected), square, carrier ? "" : PedigreeSymbol.leftHalf(PedigreeSex.Male, c, 0, m), carrier ? [c, 2] : void 0),
+			...entry("Deceased", some((d) => d.person.deceased), `${square}M${slash.x1} ${slash.y1}L${slash.x2} ${slash.y2}`),
+			...entry("Proband", some((d) => d.person.proband), arrow.shaft, arrow.head),
+			...entry("Consanguineous", couples.some((couple) => couple.consanguineous), `M0 -2.5H14M0 2.5H14`)
+		];
+	}
+	/** Greedy rows of symbol and name. Height comes first, since it takes room from the generations. */
+	#placeKey(entries, width) {
+		let x = 0, row = 0;
+		return {
+			placed: entries.map((entry) => {
+				const cost = 19 + entry.label.length * CHAR + 14;
+				if (x && x + cost - 14 > width) {
+					x = 0;
+					row++;
+				}
+				const at = {
+					...entry,
+					key: entry.label,
+					x,
+					y: row
+				};
+				x += cost;
+				return at;
+			}),
+			height: entries.length ? (row + 1) * KEY_ROW + 4 : 0
+		};
+	}
+	#drawKey(ctx, placed, top) {
+		const groups = ctx.marks("key", "g", placed, (d) => d.key);
+		ctx.set(groups, { transform: (d) => `translate(${d.x + 4},${top + 12 + d.y * KEY_ROW})` });
+		groups.selectAll("path.key-line").data((d) => [d]).join("path").attr("class", "key-line").attr("fill", "none").attr("stroke", ctx.theme.ink).attr("stroke-width", 1.5).attr("d", (d) => d.stroke);
+		groups.selectAll("path.key-fill").data((d) => [d]).join("path").attr("class", "key-fill").attr("fill", ctx.theme.ink).attr("d", (d) => d.fill);
+		groups.selectAll("circle").data((d) => d.dot ? [d.dot] : []).join("circle").attr("fill", ctx.theme.ink).attr("cx", (d) => d[0]).attr("cy", 0).attr("r", 2);
+		ctx.text(groups.selectAll("text").data((d) => [d]).join("text"), 10.5).attr("x", 18).attr("dy", "0.35em").text((d) => d.label);
+	}
+	draw(ctx) {
+		const { options } = this;
+		const columns = options;
+		const layout = new PedigreeLayout(PedigreeRows.parse(options.data, columns));
+		const key = this.#placeKey(options.showKey ? this.#keyEntries(layout) : [], ctx.plot.width);
+		const frame = this.#frame(ctx, layout, key.height);
+		this.#drawGenerations(ctx, layout, frame);
+		this.#drawLines(ctx, layout, frame);
+		this.#drawSymbols(ctx, layout.people, frame);
+		this.#drawProbands(ctx, layout.people, frame);
+		this.#drawCaptions(ctx, layout.people, layout, frame);
+		this.#drawKey(ctx, key.placed, frame.keyTop);
+	}
+};
+export { PedigreeChart };