@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/scatter/VoronoiScatter.js

@@ -0,0 +1,128 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { ScatterGeometry } from "./ScatterGeometry.js";
+import { ScatterBase, ScatterScaling } from "./ScatterBase.js";
+import { group, line, polygonArea, polygonCentroid } from "d3";
+import { Delaunay as Delaunay$1 } from "d3-delaunay";
+// src/charts/scatter/VoronoiScatter.ts
+var Tessellation = /* @__PURE__ */ function(Tessellation) {
+	Tessellation["Voronoi"] = "voronoi";
+	Tessellation["Delaunay"] = "delaunay";
+	Tessellation["Gabriel"] = "gabriel";
+	Tessellation["SpanningTree"] = "spanning-tree";
+	Tessellation["Nearest"] = "nearest-neighbour";
+	return Tessellation;
+}({});
+var NeighbourScope = /* @__PURE__ */ function(NeighbourScope) {
+	NeighbourScope["All"] = "all-points";
+	NeighbourScope["WithinGroup"] = "within-group";
+	return NeighbourScope;
+}({});
+/** Proximity structure behind a scatter: Voronoi territories, or neighbour and spanning graphs. */
+var VoronoiScatter = class extends ScatterBase {
+	static meta = {
+		id: "voronoi-scatter",
+		name: "Voronoi scatter",
+		family: ChartFamily.Relationship,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Partitions the plane around each point, or links points by proximity, to expose neighbourhoods.",
+		tags: [
+			"delaunay",
+			"minimum spanning tree",
+			"gabriel graph",
+			"nearest neighbour",
+			"tessellation"
+		],
+		sample: (seed) => SampleData.points(seed, 70, 3),
+		variants: {
+			tessellation: [
+				"voronoi",
+				"delaunay",
+				"gabriel",
+				"spanning-tree",
+				"nearest-neighbour"
+			],
+			scope: ["all-points", "within-group"],
+			cellGap: [0, 3],
+			markers: [true, false],
+			scaling: [ScatterScaling.Linear, ScatterScaling.LogLog]
+		},
+		valid: (v) => v.tessellation === "voronoi" ? v.scope === "all-points" : v.cellGap === 0
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			tessellation: "voronoi",
+			scope: "all-points",
+			cellGap: 0,
+			markers: true,
+			radius: 3.5
+		};
+	}
+	sets(points) {
+		return this.options.scope === "within-group" ? [...group(points, (point) => point.group).values()] : [points];
+	}
+	cells(set, ctx) {
+		const { width, height } = ctx.plot, gap = this.options.cellGap;
+		const voronoi = Delaunay$1.from(set, (d) => d.px, (d) => d.py).voronoi([
+			0,
+			0,
+			width,
+			height
+		]);
+		return set.flatMap((point, i) => {
+			const ring = voronoi.cellPolygon(i);
+			if (!ring) return [];
+			const open = ring.slice(0, -1), [cx, cy] = polygonCentroid(open), area = Math.abs(polygonArea(open));
+			const factor = gap ? Math.max(.1, 1 - gap / Math.sqrt(area / Math.PI || 1)) : 1;
+			const inset = open.map(([x, y]) => [cx + (x - cx) * factor, cy + (y - cy) * factor]);
+			return [{
+				point,
+				area,
+				id: `${point.group}/${point.index}`,
+				d: `${line()(inset)}Z`
+			}];
+		});
+	}
+	links(set) {
+		const { tessellation } = this.options;
+		const vertices = set.map((point) => [point.px, point.py]);
+		const edges = ScatterGeometry.delaunayEdges(vertices);
+		return ({
+			["gabriel"]: ScatterGeometry.gabriel,
+			["spanning-tree"]: ScatterGeometry.spanningTree,
+			["nearest-neighbour"]: ScatterGeometry.nearestNeighbours
+		}[tessellation]?.(vertices, edges) ?? edges).map(({ a, b }) => ({
+			id: `${set[a].index}/${set[b].index}`,
+			a: set[a],
+			b: set[b],
+			key: set[a].group
+		}));
+	}
+	plotPoints(ctx, _axes, points) {
+		const voronoi = this.options.tessellation === "voronoi", within = this.options.scope === "within-group";
+		const sets = this.sets(points).filter((set) => set.length);
+		const cells = voronoi ? sets.flatMap((set) => this.cells(set, ctx)) : [];
+		const shapes = ctx.marks("cells", "path", cells, (d) => d.id).attr("fill", (d) => this.hue(ctx, d.point)).attr("fill-opacity", .16).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(shapes, { d: (d) => d.d });
+		ctx.hover(shapes, (d) => ({
+			...this.tooltip(ctx, d.point),
+			rows: [...this.tooltip(ctx, d.point).rows, ["Cell px²", Math.round(d.area)]]
+		}));
+		const links = voronoi ? [] : sets.flatMap((set) => this.links(set));
+		const lines = ctx.marks("links", "line", links, (d) => d.id).attr("stroke", (d) => within ? ctx.palette.color(d.key) : ctx.theme.axis).attr("stroke-width", 1.5).attr("stroke-linecap", "round");
+		ctx.set(lines, {
+			x1: (d) => d.a.px,
+			y1: (d) => d.a.py,
+			x2: (d) => d.b.px,
+			y2: (d) => d.b.py
+		});
+		ctx.hover(lines, (d) => ({
+			title: "Neighbours",
+			rows: [["Length px", Math.round(Math.hypot(d.a.px - d.b.px, d.a.py - d.b.py))]]
+		}));
+		this.drawDots(ctx, this.options.markers ? points : []);
+	}
+};
+export { NeighbourScope, Tessellation, VoronoiScatter };

package/dist/charts/scatter/index.js

@@ -0,0 +1,53 @@
+import { SCATTER_ALL, ScatterBase, ScatterDomain, ScatterMarker, ScatterScaling, scatterKey, scatterNumber, thinLogTicks } from "./ScatterBase.js";
+import { CategoryScatterBase, CategorySort, CategorySummary } from "./CategoryScatterBase.js";
+import { BeeswarmLanes, BeeswarmLayout, BeeswarmScatter, BeeswarmSide } from "./BeeswarmScatter.js";
+import { BubbleChart, BubblePlacement } from "./BubbleChart.js";
+import { ConnectedArrows, ConnectedDotMode, ConnectedScatter } from "./ConnectedScatter.js";
+import { ScatterGeometry } from "./ScatterGeometry.js";
+import { ConvexHullScatter, HullScope, HullShape } from "./ConvexHullScatter.js";
+import { EllipseEstimator, EllipseScatter, EllipseScope } from "./EllipseScatter.js";
+import { ErrorBarScatter, ErrorDirection, ErrorSide, ErrorStyle } from "./ErrorBarScatter.js";
+import { BinCount, BinEncoding, BinnedScatterBase } from "./BinnedScatterBase.js";
+import { GridBinScatter, ScatterBinRule, ScatterGridCell } from "./GridBinScatter.js";
+import { HexbinScatter } from "./HexbinScatter.js";
+import { JitterMethod, JitterPlot } from "./JitterPlot.js";
+import { MarginalKind, MarginalScatter, MarginalSides, MarginalSplit } from "./MarginalScatter.js";
+import { QuadrantChart, QuadrantSplit } from "./QuadrantChart.js";
+import { Regression, RegressionMethod } from "./Regression.js";
+import { RegressionBand, RegressionScatter, RegressionScope } from "./RegressionScatter.js";
+import { RugAxes, RugMark, RugPlacement, RugScatter } from "./RugScatter.js";
+import { ScatterPlot } from "./ScatterPlot.js";
+import { StripScatter, StripScatterMark } from "./StripScatter.js";
+import { NeighbourScope, Tessellation, VoronoiScatter } from "./VoronoiScatter.js";
+import { ChangePath, ChangeScatter, ChangeStyle } from "./ChangeScatter.js";
+import { ContourScatter, ScatterContourLevels, ScatterContourPoints, ScatterContourScope } from "./ContourScatter.js";
+import { DropAxis, DropLineScatter, DropReference } from "./DropLineScatter.js";
+import { LabelLayout, LabelLeader, LabelSelection, LabelledScatter } from "./LabelledScatter.js";
+import { ParetoGoal, ParetoScatter, ParetoStep } from "./ParetoScatter.js";
+import { SunflowerLattice, SunflowerScatter, SunflowerScatterPetal } from "./SunflowerScatter.js";
+// src/charts/scatter/index.ts
+var scatterCatalog = [
+	ScatterPlot,
+	BubbleChart,
+	RegressionScatter,
+	JitterPlot,
+	StripScatter,
+	QuadrantChart,
+	ConnectedScatter,
+	HexbinScatter,
+	GridBinScatter,
+	RugScatter,
+	MarginalScatter,
+	ErrorBarScatter,
+	EllipseScatter,
+	ConvexHullScatter,
+	VoronoiScatter,
+	LabelledScatter,
+	BeeswarmScatter,
+	ContourScatter,
+	ParetoScatter,
+	DropLineScatter,
+	ChangeScatter,
+	SunflowerScatter
+];
+export { BeeswarmLanes, BeeswarmLayout, BeeswarmScatter, BeeswarmSide, BinCount, BinEncoding, BinnedScatterBase, BubbleChart, BubblePlacement, CategoryScatterBase, CategorySort, CategorySummary, ChangePath, ChangeScatter, ChangeStyle, ConnectedArrows, ConnectedDotMode, ConnectedScatter, ContourScatter, ConvexHullScatter, DropAxis, DropLineScatter, DropReference, EllipseEstimator, EllipseScatter, EllipseScope, ErrorBarScatter, ErrorDirection, ErrorSide, ErrorStyle, GridBinScatter, HexbinScatter, HullScope, HullShape, JitterMethod, JitterPlot, LabelLayout, LabelLeader, LabelSelection, LabelledScatter, MarginalKind, MarginalScatter, MarginalSides, MarginalSplit, NeighbourScope, ParetoGoal, ParetoScatter, ParetoStep, QuadrantChart, QuadrantSplit, Regression, RegressionBand, RegressionMethod, RegressionScatter, RegressionScope, RugAxes, RugMark, RugPlacement, RugScatter, SCATTER_ALL, ScatterBase, ScatterBinRule, ScatterContourLevels, ScatterContourPoints, ScatterContourScope, ScatterDomain, ScatterGeometry, ScatterGridCell, ScatterMarker, ScatterPlot, ScatterScaling, StripScatter, StripScatterMark, SunflowerLattice, SunflowerScatter, SunflowerScatterPetal, Tessellation, VoronoiScatter, scatterCatalog, scatterKey, scatterNumber, thinLogTicks };

package/dist/charts/scientific/Atmosphere.js

@@ -0,0 +1,57 @@
+// src/charts/scientific/Atmosphere.ts
+var KAPPA = .2854;
+var RD = 287.05;
+var CP = 1005;
+var LV = 2501e3;
+var EPSILON = .622;
+/** Thermodynamic formulae for sounding diagrams. Temperatures in °C, pressure in hPa. */
+var Atmosphere = class Atmosphere {
+	static saturationVapor(celsius) {
+		return 6.112 * Math.exp(17.67 * celsius / (celsius + 243.5));
+	}
+	static mixingRatio(celsius, pressure) {
+		const e = Atmosphere.saturationVapor(celsius);
+		return EPSILON * e / Math.max(.001, pressure - e);
+	}
+	static dryAdiabat(theta, pressure) {
+		return (theta + 273.15) * (pressure / 1e3) ** KAPPA - 273.15;
+	}
+	/** Dew point of air with mixing ratio `grams` g/kg at `pressure`. */
+	static dewpoint(grams, pressure) {
+		const log = Math.log(pressure * grams / (622 + grams) / 6.112);
+		return 243.5 * log / (17.67 - log);
+	}
+	/** Follows a saturated parcel from `start` hPa at `celsius` to `end` hPa. */
+	static moistAscent(celsius, start, end, steps = 24) {
+		const dlnp = Math.log(end / start) / steps;
+		let t = celsius + 273.15, p = start;
+		const path = [{
+			pressure: p,
+			temperature: celsius
+		}];
+		for (let i = 0; i < steps; i++) {
+			const rs = Atmosphere.mixingRatio(t - 273.15, p);
+			const gradient = RD * t / CP * (1 + LV * rs / (RD * t)) / (1 + LV * LV * rs * EPSILON / (CP * RD * t * t));
+			t += gradient * dlnp;
+			p *= Math.exp(dlnp);
+			path.push({
+				pressure: p,
+				temperature: t - 273.15
+			});
+		}
+		return path;
+	}
+	/** Lifting condensation level of surface air. */
+	static condensationLevel(temperature, dewpoint, pressure) {
+		const level = dewpoint - (.001296 * dewpoint + .1963) * (temperature - dewpoint);
+		return {
+			temperature: level,
+			pressure: pressure * ((level + 273.15) / (temperature + 273.15)) ** (1 / KAPPA)
+		};
+	}
+	/** Buoyant energy of a layer with mean parcel excess `excess` K, J/kg. */
+	static buoyancy(excess, lower, upper) {
+		return RD * excess * Math.log(lower / upper);
+	}
+};
+export { Atmosphere };

package/dist/charts/scientific/ChromatogramChart.js

@@ -0,0 +1,213 @@
+import { CartesianChart } from "../../core/CartesianChart.js";
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { Draft } from "./Draft.js";
+import { PeakFinder } from "./PeakFinder.js";
+import { ScientificSample } from "./ScientificSample.js";
+import { area, extent, line, max, min, scaleLinear } from "d3";
+// src/charts/scientific/ChromatogramChart.ts
+var ChromatogramBaseline = /* @__PURE__ */ function(ChromatogramBaseline) {
+	ChromatogramBaseline["Rolling"] = "rolling-baseline";
+	ChromatogramBaseline["Linear"] = "linear-baseline";
+	ChromatogramBaseline["Raw"] = "raw-baseline";
+	return ChromatogramBaseline;
+}({});
+var ChromatogramLayout = /* @__PURE__ */ function(ChromatogramLayout) {
+	ChromatogramLayout["Overlay"] = "overlay";
+	ChromatogramLayout["Offset"] = "offset";
+	ChromatogramLayout["Mirror"] = "mirror";
+	return ChromatogramLayout;
+}({});
+var ChromatogramPeaks = /* @__PURE__ */ function(ChromatogramPeaks) {
+	ChromatogramPeaks["Labelled"] = "labelled";
+	ChromatogramPeaks["Integrated"] = "integrated";
+	ChromatogramPeaks["None"] = "no-peaks";
+	return ChromatogramPeaks;
+}({});
+/** Detector response over retention time, for separating and quantifying compounds. */
+var ChromatogramChart = class extends CartesianChart {
+	static meta = {
+		id: "chromatogram",
+		name: "Chromatogram",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots detector signal over retention time with baseline correction, peak picking and integration.",
+		tags: [
+			"hplc",
+			"gas chromatography",
+			"analytical chemistry"
+		],
+		sample: (seed) => ScientificSample.chromatogram(seed),
+		variants: {
+			baseline: Object.values(ChromatogramBaseline),
+			layout: Object.values(ChromatogramLayout),
+			peaks: Object.values(ChromatogramPeaks),
+			gradient: [false, true]
+		}
+	};
+	defaults() {
+		return {
+			time: "time",
+			signal: "signal",
+			trace: "trace",
+			xLabel: "Retention time",
+			grid: true,
+			baseline: "rolling-baseline",
+			layout: "overlay",
+			peaks: "labelled",
+			gradient: false,
+			program: [
+				[0, 5],
+				[14, 95],
+				[17, 95],
+				[18, 5],
+				[20, 5]
+			],
+			prominence: .05
+		};
+	}
+	/** Removes drift with a rolling minimum, then smooths it. */
+	rolling(y) {
+		const reach = Math.max(4, Math.round(y.length / 14));
+		const floor = y.map((_, i) => min(y.slice(Math.max(0, i - reach), i + reach + 1)));
+		return floor.map((_, i) => {
+			const part = floor.slice(Math.max(0, i - reach), i + reach + 1);
+			return part.reduce((a, b) => a + b, 0) / part.length;
+		});
+	}
+	traces() {
+		const { data, time, signal, trace, baseline, prominence, layout } = this.options;
+		const names = /* @__PURE__ */ new Map();
+		for (const row of data) {
+			const t = Draft.number(row[time]), s = Draft.number(row[signal]);
+			if (t === null || s === null) continue;
+			const name = String(row[trace] ?? "Signal");
+			if (!names.has(name)) names.set(name, []);
+			names.get(name).push([t, s]);
+		}
+		return [...names].slice(0, layout === "mirror" ? 2 : void 0).map(([name, points]) => {
+			const sorted = [...points].sort((a, b) => a[0] - b[0]), x = sorted.map((d) => d[0]), y = sorted.map((d) => d[1]);
+			const count = y.length, a = y[0] ?? 0, b = y[count - 1] ?? 0;
+			const removed = baseline === "rolling-baseline" ? this.rolling(y) : baseline === "linear-baseline" ? y.map((_, i) => a + (b - a) * i / Math.max(1, count - 1)) : y.map(() => 0);
+			const shown = y.map((v, i) => v - removed[i]);
+			return {
+				name,
+				x,
+				y,
+				shown,
+				peaks: PeakFinder.find(x, shown, prominence)
+			};
+		});
+	}
+	offset(traces) {
+		return this.options.layout === "offset" ? (max(traces.flatMap((d) => d.shown)) ?? 0) * .32 : 0;
+	}
+	scales(ctx) {
+		const traces = this.traces();
+		const [left = 0, right = 1] = extent(traces.flatMap((d) => d.x));
+		const high = max(traces.flatMap((d) => d.shown)) ?? 1, low = Math.min(0, min(traces.flatMap((d) => d.shown)) ?? 0);
+		const lift = this.offset(traces) * Math.max(0, traces.length - 1);
+		const mirror = this.options.layout === "mirror";
+		return {
+			x: scaleLinear([left, right], [0, ctx.plot.width]),
+			y: scaleLinear([mirror ? -high * 1.08 : low, (high + lift) * 1.1], [ctx.plot.height, 0]).nice()
+		};
+	}
+	tickFormat(scale) {
+		const base = super.tickFormat(scale);
+		if (!base || this.options.layout !== "mirror") return base;
+		return (value) => base(Math.abs(+value));
+	}
+	draw(ctx) {
+		Draft.fresh(ctx, this.meta, this.options);
+		super.draw(ctx);
+	}
+	plotMarks(ctx, { x, y }) {
+		const { layout, peaks, gradient, program } = this.options;
+		const traces = this.traces();
+		const step = this.offset(traces);
+		const value = (trace, v) => {
+			const index = traces.indexOf(trace);
+			return layout === "mirror" && index === 1 ? -v : v + index * step;
+		};
+		const curve = (trace) => line().x((_, i) => x(trace.x[i])).y((v) => y(value(trace, v)))(trace.shown) ?? "";
+		const zero = (trace) => y(value(trace, 0));
+		if (peaks === "integrated") {
+			const slices = traces.flatMap((trace) => trace.peaks.map((peak) => ({
+				trace,
+				peak
+			})));
+			const shape = ({ trace, peak }) => {
+				const span = Array.from({ length: peak.end - peak.start + 1 }, (_, k) => peak.start + k);
+				return area().x((i) => x(trace.x[i])).y0(() => zero(trace)).y1((i) => y(value(trace, trace.shown[i])))(span) ?? "";
+			};
+			const fills = ctx.marks("peak-areas", "path", slices, ({ trace }, i) => `${trace.name}/${i}`).attr("fill", ({ trace }) => ctx.palette.color(trace.name)).attr("fill-opacity", .28);
+			ctx.set(fills, { d: shape }, { d: shape });
+			ctx.hover(fills, ({ trace, peak }) => ({
+				title: `${trace.x[peak.apex].toFixed(2)} min`,
+				color: ctx.palette.color(trace.name),
+				rows: [["Area", +peak.area.toFixed(1)], ["Height", +peak.height.toFixed(1)]]
+			}));
+		}
+		if (gradient) {
+			const percent = scaleLinear([0, 100], [ctx.plot.height, 0]);
+			Draft.paths(ctx, "gradient", [Draft.clipped((program ?? []).map((d) => [x(d[0]), percent(d[1])]), ctx.plot.width, ctx.plot.height)], {
+				stroke: ctx.theme.inkMuted,
+				dash: "6 3",
+				width: 1.5
+			});
+			Draft.captions(ctx, "gradient-name", [{
+				text: "% solvent B",
+				x: 4,
+				y: 12,
+				anchor: "start",
+				size: 10,
+				tone: "muted"
+			}]);
+		}
+		const lines = ctx.marks("traces", "path", traces, (d) => d.name).attr("fill", "none").attr("stroke", (d) => ctx.palette.color(d.name)).attr("stroke-width", 2).attr("stroke-linejoin", "round");
+		ctx.set(lines, { d: curve }, { d: curve });
+		ctx.drawOn(lines);
+		ctx.hover(lines, (d) => ({
+			title: d.name,
+			color: ctx.palette.color(d.name),
+			rows: [["Peaks", d.peaks.length]]
+		}));
+		const bases = layout === "overlay" ? [] : traces.map((trace) => ({
+			x1: 0,
+			x2: ctx.plot.width,
+			y1: zero(trace),
+			y2: zero(trace)
+		}));
+		Draft.rules(ctx, "baselines", bases, { stroke: ctx.theme.axis });
+		const apexes = peaks === "no-peaks" ? [] : traces.flatMap((trace) => trace.peaks.map((peak) => ({
+			trace,
+			peak
+		})));
+		const dots = ctx.marks("apexes", "circle", apexes, ({ trace }, i) => `${trace.name}/${i}`).attr("fill", "transparent");
+		ctx.set(dots, {
+			cx: ({ trace, peak }) => x(trace.x[peak.apex]),
+			cy: ({ trace, peak }) => y(value(trace, trace.shown[peak.apex])),
+			r: 8
+		}, {
+			cx: ({ trace, peak }) => x(trace.x[peak.apex]),
+			cy: ({ trace, peak }) => y(value(trace, trace.shown[peak.apex])),
+			r: 8
+		});
+		ctx.hover(dots, ({ trace, peak }) => ({
+			title: `${trace.x[peak.apex].toFixed(2)} min`,
+			color: ctx.palette.color(trace.name),
+			rows: [["Height", +peak.height.toFixed(1)], ["Area", +peak.area.toFixed(1)]]
+		}));
+		const labelled = peaks !== "labelled" ? [] : apexes.filter(({ trace }) => layout !== "overlay" || trace === traces[0]);
+		const flip = (trace) => layout === "mirror" && traces.indexOf(trace) === 1;
+		const captions = labelled.map(({ trace, peak }) => ({
+			text: trace.x[peak.apex].toFixed(1),
+			x: x(trace.x[peak.apex]),
+			y: y(value(trace, trace.shown[peak.apex])) + (flip(trace) ? 13 : -5),
+			size: 10
+		}));
+		Draft.captions(ctx, "retention", Draft.declutter(captions, ctx.plot.width, ctx.plot.height));
+	}
+};
+export { ChromatogramBaseline, ChromatogramChart, ChromatogramLayout, ChromatogramPeaks };

package/dist/charts/scientific/ClimateChart.js

@@ -0,0 +1,71 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { Draft } from "./Draft.js";
+import { mean, rollup } from "d3";
+// src/charts/scientific/ClimateChart.ts
+var ClimateYearStart = /* @__PURE__ */ function(ClimateYearStart) {
+	ClimateYearStart["January"] = "january-start";
+	ClimateYearStart["July"] = "july-start";
+	return ClimateYearStart;
+}({});
+var NAMES = [
+	"J",
+	"F",
+	"M",
+	"A",
+	"M",
+	"J",
+	"J",
+	"A",
+	"S",
+	"O",
+	"N",
+	"D"
+];
+/** Climate normals shared by climate diagrams: monthly aggregation, station choice and year rotation. */
+var ClimateChart = class extends Chart2D {
+	defaults() {
+		return {
+			month: "month",
+			temperature: "temperature",
+			precipitation: "precipitation",
+			tmin: "tmin",
+			tmax: "tmax",
+			station: "station",
+			start: "january-start"
+		};
+	}
+	get stations() {
+		const { data, station } = this.options;
+		return [...new Set(data.map((row) => row[station]).filter((name) => name !== null && name !== void 0).map(String))];
+	}
+	get site() {
+		return this.options.site ?? this.stations[0] ?? null;
+	}
+	/** Twelve rotated months for one station; months with no data are left out. */
+	months(site = this.site) {
+		const { data, month, temperature, precipitation, tmin, tmax, station, start } = this.options;
+		const rows = data.filter((row) => site === null || String(row[station]) === site);
+		const average = (list, key) => {
+			const values = list.flatMap((row) => {
+				const v = Draft.number(row[key]);
+				return v === null ? [] : [v];
+			});
+			return values.length ? mean(values) : null;
+		};
+		const months = [...rollup(rows, (list) => list, (row) => Draft.number(row[month]))].flatMap(([index, list]) => {
+			const temp = average(list, temperature), rain = average(list, precipitation);
+			if (index === null || temp === null || rain === null || index < 1 || index > 12) return [];
+			return [{
+				month: index,
+				label: NAMES[index - 1],
+				temperature: temp,
+				precipitation: rain,
+				tmin: average(list, tmin),
+				tmax: average(list, tmax)
+			}];
+		});
+		const first = start === "july-start" ? 7 : 1;
+		return months.sort((a, b) => (a.month - first + 12) % 12 - (b.month - first + 12) % 12);
+	}
+};
+export { ClimateChart, ClimateYearStart };