@mstone6969/graph 0.1.0 → 0.2.0

package/dist/charts/lifescience/PedigreeLayout.js

@@ -0,0 +1,261 @@
+import { PedigreeSex } from "./pedigreeEnums.js";
+import { mean } from "d3";
+// src/charts/lifescience/PedigreeLayout.ts
+var SWEEPS = 12;
+var LANE_GAP = .4;
+var FAINT = .01;
+/**
+* Lays a pedigree out in unit slots, one symbol per slot. People married to each other form a family
+* block on one row, a row being a generation. Blocks are ordered depth-first, which keeps birth order
+* within a sibship and avoids crossings on tree-shaped pedigrees, then slid under their parents and
+* over their children by least squares, so nothing swaps. Sibship lines that overlap take separate lanes.
+*/
+var PedigreeLayout = class PedigreeLayout {
+	people;
+	couples;
+	sibships;
+	generations;
+	extent;
+	/** Sibship lanes used in the gap under each generation. */
+	lanes;
+	#persons;
+	#unions = /* @__PURE__ */ new Map();
+	#families = /* @__PURE__ */ new Map();
+	#ancestors = /* @__PURE__ */ new Map();
+	constructor(persons) {
+		this.#persons = new Map(persons.map((person) => [person.key, person]));
+		this.#link(persons);
+		const families = this.#groupFamilies();
+		PedigreeLayout.#assignGenerations(families, this.#families);
+		const rows = this.#order(families);
+		this.generations = rows.length;
+		this.#place(rows);
+		const shift = families.length ? Math.min(...families.map((family) => family.left)) : 0;
+		for (const family of families) family.left -= shift;
+		const placed = /* @__PURE__ */ new Map();
+		rows.forEach((row, generation) => {
+			let number = 0;
+			for (const family of [...row].sort((a, b) => a.left - b.left)) family.members.forEach((key, i) => placed.set(key, {
+				person: this.#persons.get(key),
+				generation,
+				number: ++number,
+				x: family.left + i
+			}));
+		});
+		this.people = [...placed.values()];
+		this.extent = Math.max(0, ...this.people.map((item) => item.x));
+		const unions = [...this.#unions.values()];
+		this.couples = unions.filter((union) => union.members.length === 2).map((union) => this.#couple(union, placed));
+		this.lanes = Array.from({ length: rows.length }, () => 0);
+		this.sibships = this.#sibships(unions, placed);
+	}
+	#link(persons) {
+		const union = (members) => {
+			const key = [...members].sort().join("\0");
+			let found = this.#unions.get(key);
+			if (!found) this.#unions.set(key, found = {
+				key,
+				members,
+				children: [],
+				flagged: false
+			});
+			return found;
+		};
+		for (const person of persons) {
+			const parents = [person.father, person.mother].filter((id) => !!id);
+			if (parents.length) {
+				const family = union(parents);
+				family.children.push(person.key);
+				family.flagged ||= person.consanguineous;
+			}
+			if (person.partner) union([person.key, person.partner]).flagged ||= person.consanguineous;
+		}
+	}
+	#groupFamilies() {
+		const families = [];
+		for (const key of this.#persons.keys()) {
+			if (this.#families.has(key)) continue;
+			const family = {
+				members: [],
+				unions: [],
+				generation: 0,
+				left: 0,
+				seen: false
+			};
+			const stack = [key];
+			while (stack.length) {
+				const next = stack.pop();
+				if (this.#families.has(next)) continue;
+				this.#families.set(next, family);
+				family.members.push(next);
+				for (const union of this.#unions.values()) if (union.members.includes(next) && union.members.length === 2) stack.push(...union.members);
+			}
+			family.unions = [...this.#unions.values()].filter((union) => union.members.some((member) => family.members.includes(member)));
+			family.members = this.#chain(family);
+			families.push(family);
+		}
+		return families;
+	}
+	/** Partners side by side: a walk from an end of the marriage chain. A partner it cannot reach next to their spouse is routed over. */
+	#chain(family) {
+		const partners = (key) => family.unions.filter((union) => union.members.length === 2 && union.members.includes(key)).map((union) => union.members.find((member) => member !== key));
+		const start = [...family.members].sort((a, b) => partners(a).length - partners(b).length)[0];
+		const order = [];
+		const walk = (key) => {
+			if (order.includes(key)) return;
+			order.push(key);
+			partners(key).forEach(walk);
+		};
+		walk(start);
+		return order;
+	}
+	/** Longest path down from the founders, then founders settle onto the row above their children. */
+	static #assignGenerations(families, of) {
+		const edges = families.flatMap((family) => family.unions.filter((union) => union.members.every((member) => family.members.includes(member))).flatMap((union) => union.children.map((child) => ({
+			from: family,
+			to: of.get(child)
+		})))).filter(({ from, to }) => from !== to);
+		for (let pass = 0; pass <= families.length; pass++) {
+			let moved = false;
+			for (const { from, to } of edges) if (to.generation <= from.generation) {
+				to.generation = from.generation + 1;
+				moved = true;
+			}
+			if (!moved) break;
+		}
+		for (let pass = 0; pass <= families.length; pass++) {
+			let moved = false;
+			for (const family of families) {
+				const below = edges.filter((edge) => edge.from === family);
+				const sibling = edges.filter((edge) => edge.to === family).flatMap(({ from }) => edges.filter((edge) => edge.from === from).map((edge) => edge.to.generation));
+				const target = below.length ? Math.min(...below.map((edge) => edge.to.generation)) - 1 : sibling.length ? Math.max(...sibling) : family.generation;
+				if (target > family.generation) {
+					family.generation = target;
+					moved = true;
+				}
+			}
+			if (!moved) break;
+		}
+		const used = [...new Set(families.map((family) => family.generation))].sort((a, b) => a - b);
+		for (const family of families) family.generation = used.indexOf(family.generation);
+	}
+	#order(families) {
+		const rows = Array.from({ length: Math.max(0, ...families.map((family) => family.generation + 1)) }, () => []);
+		const parentsOf = (key) => {
+			const { father, mother } = this.#persons.get(key);
+			return father ?? mother;
+		};
+		const visit = (family, entry) => {
+			if (family.seen) return;
+			family.seen = true;
+			rows[family.generation].push(family);
+			if (family.members.length === 2) {
+				const [a, b] = family.members;
+				const both = parentsOf(a) && parentsOf(b);
+				const male = (key) => this.#persons.get(key).sex === PedigreeSex.Male;
+				if (both && entry ? b === entry : male(b) && !male(a)) family.members.reverse();
+			}
+			for (const member of [...family.members]) for (const union of family.unions) if (union.members.includes(member)) for (const child of union.children) visit(this.#families.get(child), child);
+		};
+		const founders = families.filter((family) => family.members.every((key) => !parentsOf(key)));
+		for (const family of [...founders, ...families]) visit(family, null);
+		return rows;
+	}
+	#x(key) {
+		const family = this.#families.get(key);
+		return family.left + family.members.indexOf(key);
+	}
+	#place(rows) {
+		for (const row of rows) PedigreeLayout.#solve(row, () => null);
+		const down = (family) => mean(family.members.flatMap((key, i) => {
+			const parents = [...this.#unions.values()].find((union) => union.children.includes(key));
+			return parents ? [mean(parents.members, (member) => this.#x(member)) - i] : [];
+		}));
+		const up = (family) => mean(family.unions.flatMap((union) => {
+			if (!union.children.length || !union.members.every((member) => family.members.includes(member))) return [];
+			return [mean(union.children, (child) => this.#x(child)) - mean(union.members, (member) => family.members.indexOf(member))];
+		}));
+		for (let sweep = 0; sweep < SWEEPS; sweep++) {
+			for (const row of rows) PedigreeLayout.#solve(row, down);
+			for (const row of [...rows].reverse()) PedigreeLayout.#solve(row, up);
+		}
+	}
+	/** Pool-adjacent-violators: the closest positions to `wanted`, in least squares, that keep the row's order and spacing. */
+	static #solve(row, wanted) {
+		const offsets = [], blocks = [];
+		let offset = 0;
+		for (const family of row) {
+			const want = wanted(family);
+			offsets.push(offset);
+			blocks.push({
+				value: (want ?? family.left) - offset,
+				weight: want == null ? FAINT : 1,
+				size: 1
+			});
+			offset += family.members.length;
+			while (blocks.length > 1 && blocks.at(-2).value > blocks.at(-1).value) {
+				const top = blocks.pop(), under = blocks.at(-1), weight = under.weight + top.weight;
+				under.value = (under.value * under.weight + top.value * top.weight) / weight;
+				under.weight = weight;
+				under.size += top.size;
+			}
+		}
+		let at = 0;
+		for (const block of blocks) for (let i = 0; i < block.size; i++, at++) row[at].left = block.value + offsets[at];
+	}
+	/** Everyone this person descends from. A loop in bad data simply stops the walk. */
+	#ancestry(key) {
+		const known = this.#ancestors.get(key);
+		if (known) return known;
+		const found = /* @__PURE__ */ new Set();
+		this.#ancestors.set(key, found);
+		const { father, mother } = this.#persons.get(key);
+		for (const parent of [father, mother]) {
+			if (!parent) continue;
+			found.add(parent);
+			for (const ancestor of this.#ancestry(parent)) found.add(ancestor);
+		}
+		return found;
+	}
+	#related(a, b) {
+		const above = this.#ancestry(a), other = this.#ancestry(b);
+		return above.has(b) || other.has(a) || [...above].some((ancestor) => other.has(ancestor));
+	}
+	#couple(union, placed) {
+		const [left, right] = union.members.map((key) => placed.get(key)).sort((a, b) => a.x - b.x);
+		return {
+			key: union.key,
+			left,
+			right,
+			adjacent: right.x - left.x <= 1.001,
+			consanguineous: union.flagged || this.#related(union.members[0], union.members[1])
+		};
+	}
+	#sibships(unions, placed) {
+		const drawn = unions.filter((union) => union.children.length).map((union) => {
+			const parents = union.members.map((key) => placed.get(key)), children = union.children.map((key) => placed.get(key));
+			const far = Math.max(...parents.map((parent) => parent.x)), near = Math.min(...parents.map((parent) => parent.x));
+			const drop = far - near > 1.001 ? far - .5 : (far + near) / 2, spots = [drop, ...children.map((child) => child.x)];
+			return {
+				key: union.key,
+				parents,
+				children,
+				drop,
+				from: Math.min(...spots),
+				to: Math.max(...spots),
+				generation: Math.max(0, Math.min(...children.map((child) => child.generation)) - 1),
+				lane: 0
+			};
+		}).sort((a, b) => a.from - b.from);
+		const ends = this.lanes.map(() => []);
+		for (const sibship of drawn) {
+			const row = ends[sibship.generation];
+			const lane = row.findIndex((end) => end + LANE_GAP <= sibship.from);
+			sibship.lane = lane < 0 ? row.length : lane;
+			row[sibship.lane] = sibship.to;
+			this.lanes[sibship.generation] = row.length;
+		}
+		return drawn;
+	}
+};
+export { PedigreeLayout };

package/dist/charts/lifescience/PedigreeRows.js

@@ -0,0 +1,70 @@
+import { PedigreeSex } from "./pedigreeEnums.js";
+// src/charts/lifescience/PedigreeRows.ts
+var MALE = /* @__PURE__ */ new Set([
+	"m",
+	"male",
+	"man",
+	"boy",
+	"1"
+]);
+var FEMALE = /* @__PURE__ */ new Set([
+	"f",
+	"female",
+	"woman",
+	"girl",
+	"2"
+]);
+var YES = /* @__PURE__ */ new Set([
+	"true",
+	"yes",
+	"y",
+	"1",
+	"x",
+	"affected",
+	"carrier",
+	"deceased",
+	"dead",
+	"proband"
+]);
+var text = (cell) => String(cell ?? "").trim();
+/**
+* Reads pedigree rows. Sex accepts words or PED codes (1 male, 2 female). Status columns are booleans,
+* so map PED affection codes first: there, 1 means unaffected. Links to an absent person are dropped.
+*/
+var PedigreeRows = class PedigreeRows {
+	static parse(data, columns) {
+		const rows = (Array.isArray(data) ? data : []).filter((row) => row !== null && typeof row === "object");
+		const known = new Set(rows.map((row) => text(row[columns.id])).filter(Boolean));
+		const link = (cell, self) => {
+			const id = text(cell);
+			return id !== self && known.has(id) ? id : null;
+		};
+		const flag = (cell) => YES.has(text(cell).toLowerCase());
+		const seen = /* @__PURE__ */ new Set();
+		return rows.flatMap((row) => {
+			const key = text(row[columns.id]);
+			if (!key || seen.has(key)) return [];
+			seen.add(key);
+			const father = link(row[columns.father], key), mother = link(row[columns.mother], key);
+			return [{
+				key,
+				row,
+				name: text(row[columns.label]) || key,
+				sex: PedigreeRows.#sex(row[columns.sex]),
+				father,
+				mother: mother === father ? null : mother,
+				partner: link(row[columns.partner], key),
+				affected: flag(row[columns.affected]),
+				carrier: flag(row[columns.carrier]),
+				deceased: flag(row[columns.deceased]),
+				proband: flag(row[columns.proband]),
+				consanguineous: flag(row[columns.consanguineous])
+			}];
+		});
+	}
+	static #sex(cell) {
+		const code = text(cell).toLowerCase();
+		return MALE.has(code) ? PedigreeSex.Male : FEMALE.has(code) ? PedigreeSex.Female : PedigreeSex.Unknown;
+	}
+};
+export { PedigreeRows };

package/dist/charts/lifescience/PedigreeSamples.js

@@ -0,0 +1,161 @@
+import { randomLcg } from "d3";
+// src/charts/lifescience/PedigreeSamples.ts
+/** [id, sex, father, mother] in birth order, four generations with a first-cousin union at 12 and 13. */
+var FAMILY = [
+	[
+		1,
+		"M",
+		null,
+		null
+	],
+	[
+		2,
+		"F",
+		null,
+		null
+	],
+	[
+		3,
+		"M",
+		null,
+		null
+	],
+	[
+		4,
+		"F",
+		1,
+		2
+	],
+	[
+		5,
+		"M",
+		1,
+		2
+	],
+	[
+		6,
+		"F",
+		null,
+		null
+	],
+	[
+		7,
+		"F",
+		1,
+		2
+	],
+	[
+		8,
+		"U",
+		1,
+		2
+	],
+	[
+		9,
+		"F",
+		3,
+		4
+	],
+	[
+		10,
+		"M",
+		3,
+		4
+	],
+	[
+		11,
+		"M",
+		3,
+		4
+	],
+	[
+		12,
+		"M",
+		3,
+		4
+	],
+	[
+		13,
+		"F",
+		5,
+		6
+	],
+	[
+		14,
+		"F",
+		5,
+		6
+	],
+	[
+		15,
+		"M",
+		5,
+		6
+	],
+	[
+		16,
+		"M",
+		12,
+		13
+	],
+	[
+		17,
+		"F",
+		12,
+		13
+	],
+	[
+		18,
+		"M",
+		12,
+		13
+	],
+	[
+		19,
+		"F",
+		12,
+		13
+	],
+	[
+		20,
+		"M",
+		12,
+		13
+	]
+];
+var COUSINS = [12, 13];
+var LAST_CHILDREN = 16;
+var TRIES = 2e3;
+/** A synthetic family, not a real one: autosomal recessive inheritance simulated by Mendel's first law. */
+var PedigreeSamples = class {
+	/** Copies of the allele per person, redrawn until the cousins are both carriers with an affected child, so every symbol appears. */
+	static #genotypes(seed) {
+		const random = randomLcg(seed * .6180339887 % 1);
+		const gamete = (copies) => copies === 2 ? 1 : copies === 1 && random() < .5 ? 1 : 0;
+		let held = /* @__PURE__ */ new Map();
+		for (let attempt = 0; attempt < TRIES; attempt++) {
+			held = /* @__PURE__ */ new Map();
+			for (const [id, , father, mother] of FAMILY) if (id === 1) held.set(id, 1);
+			else held.set(id, father === null || mother === null ? 0 : gamete(held.get(father)) + gamete(held.get(mother)));
+			const children = FAMILY.filter(([id]) => id >= LAST_CHILDREN).map(([id]) => held.get(id));
+			if (COUSINS.every((id) => held.get(id) === 1) && children.includes(2) && children.includes(1)) return held;
+		}
+		return held;
+	}
+	static recessive(seed) {
+		const copies = this.#genotypes(seed);
+		const proband = FAMILY.find(([id]) => id >= LAST_CHILDREN && copies.get(id) === 2)?.[0];
+		return FAMILY.map(([id, sex, father, mother]) => ({
+			id,
+			sex,
+			father,
+			mother,
+			label: `Syn-${id}`,
+			affected: +(copies.get(id) === 2),
+			carrier: +(copies.get(id) === 1),
+			deceased: +(id <= 3 || id === 7),
+			proband: +(id === proband)
+		}));
+	}
+};
+export { PedigreeSamples };

package/dist/charts/lifescience/PedigreeSymbol.js

@@ -0,0 +1,47 @@
+import { PedigreeSex } from "./pedigreeEnums.js";
+// src/charts/lifescience/PedigreeSymbol.ts
+var DIAMOND = .62;
+var f = (value) => +value.toFixed(2);
+/** SVG paths for the pedigree symbols: square male, circle female, diamond sex unknown. `size` is the symbol's width. */
+var PedigreeSymbol = class {
+	static outline(sex, x, y, size) {
+		const r = size / 2;
+		if (sex === PedigreeSex.Male) return `M${f(x - r)} ${f(y - r)}H${f(x + r)}V${f(y + r)}H${f(x - r)}Z`;
+		if (sex === PedigreeSex.Female) return `M${f(x - r)} ${f(y)}A${f(r)} ${f(r)} 0 1 1 ${f(x + r)} ${f(y)}A${f(r)} ${f(r)} 0 1 1 ${f(x - r)} ${f(y)}Z`;
+		const d = size * DIAMOND;
+		return `M${f(x)} ${f(y - d)}L${f(x + d)} ${f(y)}L${f(x)} ${f(y + d)}L${f(x - d)} ${f(y)}Z`;
+	}
+	/** The left half, which shades a carrier. */
+	static leftHalf(sex, x, y, size) {
+		const r = size / 2;
+		if (sex === PedigreeSex.Male) return `M${f(x)} ${f(y - r)}H${f(x - r)}V${f(y + r)}H${f(x)}Z`;
+		if (sex === PedigreeSex.Female) return `M${f(x)} ${f(y - r)}A${f(r)} ${f(r)} 0 0 0 ${f(x)} ${f(y + r)}Z`;
+		const d = size * DIAMOND;
+		return `M${f(x)} ${f(y - d)}L${f(x - d)} ${f(y)}L${f(x)} ${f(y + d)}Z`;
+	}
+	/** Half the height the symbol spans, which differs for the diamond. */
+	static reach(sex, size) {
+		return sex === PedigreeSex.Unknown ? size * DIAMOND : size / 2;
+	}
+	/** Bottom-left to top-right, overhanging the symbol so it reads on a filled one too. */
+	static slash(x, y, size) {
+		const r = size / 2 + 4;
+		return {
+			x1: f(x - r),
+			y1: f(y + r),
+			x2: f(x + r),
+			y2: f(y - r)
+		};
+	}
+	/** Arrow from the lower left up to the symbol, as a shaft and a filled head. */
+	static arrow(x, y, size) {
+		const tip = size / 2 + 3, tail = tip + Math.max(11, size * .55), back = 6 * Math.SQRT1_2;
+		const tipX = x - tip, tipY = y + tip, baseX = tipX - back, baseY = tipY + back;
+		return {
+			shaft: `M${f(x - tail)} ${f(y + tail)}L${f(baseX)} ${f(baseY)}`,
+			head: `M${f(tipX)} ${f(tipY)}L${f(baseX - back * .6)} ${f(baseY - back * .6)}L${f(baseX + back * .6)} ${f(baseY + back * .6)}Z`,
+			tail: [f(x - tail), f(y + tail)]
+		};
+	}
+};
+export { PedigreeSymbol };