@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/comparison/Tally.js

@@ -0,0 +1,129 @@
+import { ascending, deviation, group, mean, median, quantileSorted } from "d3";
+// src/charts/comparison/Tally.ts
+/** Which summary of a group of observations draws an interval. */
+var ComparisonSpread = /* @__PURE__ */ function(ComparisonSpread) {
+	ComparisonSpread["StdDev"] = "sd";
+	ComparisonSpread["StdError"] = "se";
+	ComparisonSpread["Ci95"] = "ci95";
+	ComparisonSpread["Iqr"] = "iqr";
+	ComparisonSpread["Range"] = "range";
+	ComparisonSpread["Decile"] = "p10-p90";
+	return ComparisonSpread;
+}({});
+/** Order of the bands along the category axis. */
+var ComparisonSort = /* @__PURE__ */ function(ComparisonSort) {
+	ComparisonSort["Input"] = "input";
+	ComparisonSort["Descending"] = "descending";
+	ComparisonSort["Ascending"] = "ascending";
+	ComparisonSort["Name"] = "name";
+	return ComparisonSort;
+}({});
+/** Where a central value comes from. */
+var ComparisonCenter = /* @__PURE__ */ function(ComparisonCenter) {
+	ComparisonCenter["Mean"] = "mean";
+	ComparisonCenter["Median"] = "median";
+	return ComparisonCenter;
+}({});
+var SMALL_T = [
+	12.706,
+	4.303,
+	3.182,
+	2.776
+];
+var CHAR = 6.2;
+/** Two-sided 97.5% Student t, by table then Cornish-Fisher. */
+function tCritical(df) {
+	if (df < 1) return 0;
+	const small = SMALL_T[df - 1];
+	if (small) return small;
+	const z = 1.96;
+	return z + (z ** 3 + z) / (4 * df) + (5 * z ** 5 + 16 * z ** 3 + 3 * z) / (96 * df * df);
+}
+/** Reads, groups and summarises rows for the comparison charts, tolerating missing values. */
+var Tally = class Tally {
+	/** A finite number, or null for anything missing or non-numeric. */
+	static num(cell) {
+		if (cell === null || cell === void 0 || cell === "") return null;
+		const value = +cell;
+		return Number.isFinite(value) ? value : null;
+	}
+	static values(rows, field) {
+		return rows.flatMap((row) => {
+			const value = Tally.num(row[field]);
+			return value === null ? [] : [value];
+		});
+	}
+	static of(key, values) {
+		const sorted = [...values].sort(ascending);
+		const n = sorted.length, sd = n > 1 ? deviation(sorted) : 0;
+		const at = (p) => quantileSorted(sorted, p) ?? 0;
+		return {
+			key,
+			values,
+			n,
+			mean: mean(sorted) ?? 0,
+			median: median(sorted) ?? 0,
+			sd,
+			se: n ? sd / Math.sqrt(n) : 0,
+			min: sorted[0] ?? 0,
+			max: sorted[n - 1] ?? 0,
+			q1: at(.25),
+			q3: at(.75),
+			p10: at(.1),
+			p90: at(.9)
+		};
+	}
+	/** One summary per distinct key, in first-seen order; keys with no numeric value are dropped. */
+	static group(rows, key, field) {
+		return [...group(rows, (row) => String(row[key] ?? ""))].map(([name, members]) => Tally.of(name, Tally.values(members, field))).filter((tally) => tally.n > 0);
+	}
+	static center(tally, kind) {
+		return kind === "median" ? tally.median : tally.mean;
+	}
+	/** The `[low, high]` interval; distribution-free spreads are returned as quantiles, others around the mean. */
+	static interval(tally, spread) {
+		switch (spread) {
+			case "iqr": return [tally.q1, tally.q3];
+			case "range": return [tally.min, tally.max];
+			case "p10-p90": return [tally.p10, tally.p90];
+			case "sd": return [tally.mean - tally.sd, tally.mean + tally.sd];
+			case "se": return [tally.mean - tally.se, tally.mean + tally.se];
+			default: {
+				const half = tCritical(tally.n - 1) * tally.se;
+				return [tally.mean - half, tally.mean + half];
+			}
+		}
+	}
+	static sorted(items, sort, value, name) {
+		const list = [...items];
+		if (sort === "descending") return list.sort((a, b) => value(b) - value(a));
+		if (sort === "ascending") return list.sort((a, b) => value(a) - value(b));
+		if (sort === "name") return list.sort((a, b) => name(a).localeCompare(name(b)));
+		return list;
+	}
+	static format(value) {
+		return value.toLocaleString("en", { maximumFractionDigits: Math.abs(value) < 10 ? 2 : 1 });
+	}
+	static width(text, size = 11) {
+		return text.length * CHAR * size / 11;
+	}
+	/** Fits text to `px`, ending in an ellipsis when cut. */
+	static clip(text, px, size = 11) {
+		if (Tally.width(text, size) <= px) return text;
+		const keep = Math.floor(px * 11 / (CHAR * size)) - 1;
+		return keep < 2 ? "" : `${text.slice(0, keep)}…`;
+	}
+	/**
+	* Label placement along one line: keeps every k-th label when `gap` per label cannot fit `[low, high]`,
+	* then spreads the kept ones so none overlap. Returns `[index, position]` pairs.
+	*/
+	static spread(wanted, gap, low, high) {
+		const order = wanted.map((at, index) => [index, at]).sort((a, b) => a[1] - b[1]);
+		const every = Math.max(1, Math.ceil(order.length * gap / Math.max(1, high - low)));
+		const kept = order.filter((_, i) => i % every === 0);
+		for (let i = 0; i < kept.length; i++) kept[i][1] = Math.max(kept[i][1], i ? kept[i - 1][1] + gap : low);
+		for (let i = kept.length - 1; i >= 0; i--) kept[i][1] = Math.min(kept[i][1], i < kept.length - 1 ? kept[i + 1][1] - gap : high);
+		return kept;
+	}
+};
+export { ComparisonCenter, ComparisonSort, ComparisonSpread, Tally };

package/dist/charts/comparison/index.js

@@ -0,0 +1,36 @@
+import { ComparisonCenter, ComparisonSort, ComparisonSpread, Tally } from "./Tally.js";
+import { BandValueChart } from "./BandValueChart.js";
+import { BarMeanChart, BarMeanRaw } from "./BarMeanChart.js";
+import { CycleAggregate, CycleChart, CycleMark, CycleReference, CycleUnit } from "./CycleChart.js";
+import { DeviationChart, DeviationMark, DeviationReference, DeviationUnit } from "./DeviationChart.js";
+import { ErrorBarChart, ErrorBarLink } from "./ErrorBarChart.js";
+import { EffectForestPlot, ForestMarker, ForestSort } from "./EffectForestPlot.js";
+import { FloatReference, FloatShape, FloatingBarChart } from "./FloatingBarChart.js";
+import { GaugeBarMarker, GaugeBarScale, GaugeBarTrack, GaugeBarsComparison } from "./GaugeBarsComparison.js";
+import { IntervalChart, IntervalStyle } from "./IntervalChart.js";
+import { MeanLineChart, MeanRibbon } from "./MeanLineChart.js";
+import { PairedBarChart, PairedLayout, PairedSort, PairedUnit } from "./PairedBarChart.js";
+import { ProfileScale, RadarLikeProfileChart } from "./RadarLikeProfileChart.js";
+import { RangeDotChart, RangeDotLink } from "./RangeDotChart.js";
+import { RankedDotChart, RankedLeader } from "./RankedDotChart.js";
+import { RankedSlopeLabels, RankedSlopePosition, RankedSlopeSpan, SlopeGraphRanked } from "./SlopeGraphRanked.js";
+import { LensBaseline, LensMark, LensScale, LensSort, TableLensChart } from "./TableLensChart.js";
+// src/charts/comparison/index.ts
+var comparisonCatalog = [
+	RadarLikeProfileChart,
+	TableLensChart,
+	SlopeGraphRanked,
+	BarMeanChart,
+	ErrorBarChart,
+	EffectForestPlot,
+	GaugeBarsComparison,
+	FloatingBarChart,
+	DeviationChart,
+	RangeDotChart,
+	PairedBarChart,
+	CycleChart,
+	MeanLineChart,
+	IntervalChart,
+	RankedDotChart
+];
+export { BandValueChart, BarMeanChart, BarMeanRaw, ComparisonCenter, ComparisonSort, ComparisonSpread, CycleAggregate, CycleChart, CycleMark, CycleReference, CycleUnit, DeviationChart, DeviationMark, DeviationReference, DeviationUnit, EffectForestPlot, ErrorBarChart, ErrorBarLink, FloatReference, FloatShape, FloatingBarChart, ForestMarker, ForestSort, GaugeBarMarker, GaugeBarScale, GaugeBarTrack, GaugeBarsComparison, IntervalChart, IntervalStyle, LensBaseline, LensMark, LensScale, LensSort, MeanLineChart, MeanRibbon, PairedBarChart, PairedLayout, PairedSort, PairedUnit, ProfileScale, RadarLikeProfileChart, RangeDotChart, RangeDotLink, RankedDotChart, RankedLeader, RankedSlopeLabels, RankedSlopePosition, RankedSlopeSpan, SlopeGraphRanked, TableLensChart, Tally, comparisonCatalog };

package/dist/charts/comparison/settleMarks.js

@@ -0,0 +1,9 @@
+// src/charts/comparison/settleMarks.ts
+/** `ctx.set` where new marks start in their final place, overridden by `from`, so nothing flies in from the origin. */
+function settleMarks(ctx, selection, final, from = {}, stagger = 0) {
+	return ctx.set(selection, final, {
+		...final,
+		...from
+	}, stagger);
+}
+export { settleMarks };

package/dist/charts/demography/DemographyMarks.js

@@ -0,0 +1,31 @@
+// src/charts/demography/DemographyMarks.ts
+var round = (value) => +value.toFixed(2);
+/** Small drawing helpers shared by the demography charts. */
+var DemographyMarks = class {
+	static number(cell) {
+		const value = typeof cell === "string" && cell.trim() ? +cell : cell;
+		return typeof value === "number" && Number.isFinite(value) ? value : null;
+	}
+	static polygon(points) {
+		return points.length ? `M${points.map(([x, y]) => `${round(x)},${round(y)}`).join("L")}Z` : "";
+	}
+	static segment([x1, y1], [x2, y2]) {
+		return `M${round(x1)},${round(y1)}L${round(x2)},${round(y2)}`;
+	}
+	/** Short readable figure: three significant digits, thousands grouped. */
+	static figure(value) {
+		const digits = Math.abs(value) >= 100 ? 0 : Math.abs(value) >= 10 ? 1 : Math.abs(value) >= 1 ? 2 : 3;
+		return value.toLocaleString("en", { maximumFractionDigits: digits });
+	}
+	static captions(ctx, name, items) {
+		const text = ctx.marks(name, "text", items, (d) => d.key);
+		ctx.text(text);
+		const place = (d) => `translate(${round(d.x)},${round(d.y)})${d.rotate ? ` rotate(${d.rotate})` : ""}`;
+		return text.attr("fill", (d) => ({
+			ink: ctx.theme.ink,
+			secondary: ctx.theme.inkSecondary,
+			muted: ctx.theme.inkMuted
+		})[d.tone ?? "secondary"]).attr("font-size", (d) => d.size ?? 11).attr("font-weight", (d) => d.weight ?? null).attr("text-anchor", (d) => d.anchor ?? "middle").attr("stroke", (d) => d.halo ? ctx.theme.surface : null).attr("stroke-width", (d) => d.halo ? 3 : null).attr("paint-order", "stroke").attr("transform", place).style("pointer-events", "none").text((d) => d.text);
+	}
+};
+export { DemographyMarks };

package/dist/charts/demography/LexisCells.js

@@ -0,0 +1,143 @@
+import { DemographyMarks } from "./DemographyMarks.js";
+import { group, max, min, sum } from "d3";
+// src/charts/demography/LexisCells.ts
+var LexisCellKind = /* @__PURE__ */ function(LexisCellKind) {
+	LexisCellKind["None"] = "none";
+	LexisCellKind["AgePeriod"] = "age-period";
+	LexisCellKind["Triangle"] = "triangle";
+	LexisCellKind["PeriodCohort"] = "period-cohort";
+	LexisCellKind["AgeCohort"] = "age-cohort";
+	return LexisCellKind;
+}({});
+/** Reads Human Mortality Database style Lexis rows and folds them into squares, triangles or parallelograms. */
+var LexisCells = class LexisCells {
+	/** Rows without a cohort are split evenly between the two triangles of their square. */
+	static triangles(rows, columns) {
+		return rows.flatMap((row) => {
+			const read = DemographyMarks.number;
+			const year = read(row[columns.year]), age = read(row[columns.age]), value = read(row[columns.value]);
+			if (year === null || age === null || value === null) return [];
+			const exposure = read(row[columns.exposure]) ?? 0, cohort = read(row[columns.cohort]);
+			const lower = year - age, upper = lower - 1;
+			if (cohort === null) return [{
+				year,
+				age,
+				cohort: lower,
+				upper: false,
+				value: value / 2,
+				exposure: exposure / 2
+			}, {
+				year,
+				age,
+				cohort: upper,
+				upper: true,
+				value: value / 2,
+				exposure: exposure / 2
+			}];
+			return cohort === lower || cohort === upper ? [{
+				year,
+				age,
+				cohort,
+				upper: cohort === upper,
+				value,
+				exposure
+			}] : [];
+		});
+	}
+	static bounds(triangles) {
+		if (!triangles.length) return null;
+		return {
+			year0: min(triangles, (d) => d.year),
+			year1: max(triangles, (d) => d.year) + 1,
+			age0: min(triangles, (d) => d.age),
+			age1: max(triangles, (d) => d.age) + 1
+		};
+	}
+	/** Folds triangles into cells. A cell with only one of its two triangles keeps that triangle's outline. */
+	static fold(triangles, kind, per) {
+		if (kind === "none") return [];
+		return [...group(triangles, (d) => LexisCells.#key(d, kind))].map(([key, parts]) => {
+			const first = parts[0];
+			const half = parts.every((part) => part.upper === first.upper);
+			return {
+				key,
+				title: LexisCells.#title(first, kind),
+				polygon: half ? LexisCells.#triangle(first) : LexisCells.#whole(first, kind),
+				...LexisCells.total(parts, per)
+			};
+		});
+	}
+	/** Events over exposure, per `per`. With no exposure the values are taken as counts and added. */
+	static total(parts, per) {
+		const value = sum(parts, (d) => d.value), exposure = sum(parts, (d) => d.exposure);
+		return {
+			value,
+			exposure,
+			rate: exposure > 0 ? value / exposure * per : value
+		};
+	}
+	/** The diagonal strip one birth cohort sweeps through the plane, clipped to the plane's edges. */
+	static cohortBand(cohort, { year0, year1, age0, age1 }) {
+		const start = Math.max(year0, cohort + age0), end = Math.min(year1, cohort + age1 + 1);
+		if (start >= end) return [];
+		const stops = [...new Set([
+			start,
+			end,
+			cohort + age0 + 1,
+			cohort + age1
+		].filter((year) => year >= start && year <= end))].sort((a, b) => a - b);
+		const top = stops.map((year) => [year, Math.min(age1, year - cohort)]);
+		const bottom = stops.map((year) => [year, Math.max(age0, year - cohort - 1)]).reverse();
+		return [...top, ...bottom];
+	}
+	static #key({ year, age, cohort }, kind) {
+		if (kind === "age-period") return `${year}/${age}`;
+		if (kind === "period-cohort") return `${year}/${cohort}`;
+		if (kind === "age-cohort") return `${age}/${cohort}`;
+		return `${year}/${age}/${cohort}`;
+	}
+	static #title({ year, age, cohort }, kind) {
+		if (kind === "age-period") return `${year}, age ${age}`;
+		if (kind === "period-cohort") return `${year}, born ${cohort}`;
+		if (kind === "age-cohort") return `Age ${age}, born ${cohort}`;
+		return `${year}, age ${age}, born ${cohort}`;
+	}
+	static #triangle({ year, age, upper }) {
+		return upper ? [
+			[year, age],
+			[year + 1, age + 1],
+			[year, age + 1]
+		] : [
+			[year, age],
+			[year + 1, age],
+			[year + 1, age + 1]
+		];
+	}
+	static #whole({ year, age, cohort }, kind) {
+		if (kind === "period-cohort") {
+			const a = year - cohort;
+			return [
+				[year, a - 1],
+				[year + 1, a],
+				[year + 1, a + 1],
+				[year, a]
+			];
+		}
+		if (kind === "age-cohort") {
+			const y = cohort + age;
+			return [
+				[y, age],
+				[y + 1, age],
+				[y + 2, age + 1],
+				[y + 1, age + 1]
+			];
+		}
+		return [
+			[year, age],
+			[year + 1, age],
+			[year + 1, age + 1],
+			[year, age + 1]
+		];
+	}
+};
+export { LexisCellKind, LexisCells };