@mstone6969/graph 0.0.0-stage → 0.2.0

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

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