@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/scatter/ScatterBase.js

@@ -0,0 +1,283 @@
+import { CartesianChart } from "../../core/CartesianChart.js";
+import { Scales } from "../../core/Scales.js";
+import { ScaleKind, SymbolKind } from "../../core/enums.js";
+import { extent, scaleUtc, symbol } from "d3";
+// src/charts/scatter/ScatterBase.ts
+var ScatterScaling = /* @__PURE__ */ function(ScatterScaling) {
+	ScatterScaling["Linear"] = "linear";
+	ScatterScaling["SemilogX"] = "semilog-x";
+	ScatterScaling["SemilogY"] = "semilog-y";
+	ScatterScaling["LogLog"] = "log-log";
+	ScatterScaling["SqrtX"] = "sqrt-x";
+	ScatterScaling["SqrtY"] = "sqrt-y";
+	ScatterScaling["SqrtSqrt"] = "sqrt-sqrt";
+	return ScatterScaling;
+}({});
+var X_KIND = {
+	["semilog-x"]: ScaleKind.Log,
+	["log-log"]: ScaleKind.Log,
+	["sqrt-x"]: ScaleKind.Sqrt,
+	["sqrt-sqrt"]: ScaleKind.Sqrt
+};
+var Y_KIND = {
+	["semilog-y"]: ScaleKind.Log,
+	["log-log"]: ScaleKind.Log,
+	["sqrt-y"]: ScaleKind.Sqrt,
+	["sqrt-sqrt"]: ScaleKind.Sqrt
+};
+var ScatterDomain = /* @__PURE__ */ function(ScatterDomain) {
+	ScatterDomain["Tight"] = "tight";
+	ScatterDomain["Zero"] = "zero";
+	return ScatterDomain;
+}({});
+var ScatterMarker = /* @__PURE__ */ function(ScatterMarker) {
+	ScatterMarker["Circle"] = "circle";
+	ScatterMarker["PerGroup"] = "per-group";
+	ScatterMarker["Diamond"] = "diamond";
+	ScatterMarker["Square"] = "square";
+	return ScatterMarker;
+}({});
+var GROUP_SYMBOLS = [
+	SymbolKind.Circle,
+	SymbolKind.Square,
+	SymbolKind.Diamond,
+	SymbolKind.Triangle,
+	SymbolKind.Wye,
+	SymbolKind.Star,
+	SymbolKind.Cross
+];
+var SCATTER_ALL = "All";
+var scatterNumber = (value) => value === null || value === void 0 || value === "" ? NaN : +value;
+var scatterKey = (point) => point.index;
+/** Decades crowd a log axis: above one decade of span, label only 1, 2 and 5 of each. */
+function thinLogTicks(scale, format) {
+	if (!format || !("base" in scale)) return format;
+	const [low, high] = scale.domain();
+	if (high / low < 8) return format;
+	return (value) => {
+		const lead = +value / 10 ** Math.floor(Math.log10(+value) + 1e-9);
+		return [
+			1,
+			2,
+			5
+		].some((mantissa) => Math.abs(lead - mantissa) < 1e-6) ? format(value) : "";
+	};
+}
+/** Shared pipeline of x/y point charts: clean rows, fit scales inside a frame, draw identity-coloured dots. */
+var ScatterBase = class extends CartesianChart {
+	defaults() {
+		return {
+			x: "x",
+			y: "y",
+			group: "group",
+			size: "size",
+			label: "label",
+			scaling: "linear",
+			xScale: ScaleKind.Linear,
+			yScale: ScaleKind.Linear,
+			domain: "tight",
+			marker: "circle",
+			radius: 5
+		};
+	}
+	get xKind() {
+		return X_KIND[this.options.scaling] ?? this.options.xScale;
+	}
+	get yKind() {
+		return Y_KIND[this.options.scaling] ?? this.options.yScale;
+	}
+	/** Rows with usable coordinates; a log axis cannot place values at or below zero. */
+	points() {
+		const { data, x, y, group, size, label } = this.options;
+		const xLog = this.xKind === ScaleKind.Log, yLog = this.yKind === ScaleKind.Log;
+		return (data ?? []).flatMap((row, index) => {
+			const px = scatterNumber(row[x]), py = scatterNumber(row[y]);
+			if (!Number.isFinite(px) || !Number.isFinite(py)) return [];
+			if (xLog && px <= 0 || yLog && py <= 0) return [];
+			const magnitude = scatterNumber(row[size]);
+			return [{
+				x: px,
+				y: py,
+				group: String(row[group] ?? "All"),
+				size: Number.isFinite(magnitude) ? magnitude : 0,
+				label: String(row[label] ?? ""),
+				row,
+				index
+			}];
+		});
+	}
+	/** Plot rectangle available to the point cloud. Override to reserve room for marginals. */
+	frame(ctx) {
+		return {
+			left: 0,
+			right: ctx.plot.width,
+			top: 0,
+			bottom: ctx.plot.height
+		};
+	}
+	/** Extra px between the frame and the data, for marks wider than a dot. */
+	inset() {
+		return 0;
+	}
+	/** Values the x axis must show. Override to include error extents and the like. */
+	xValues(points) {
+		return points.map((point) => point.x);
+	}
+	yValues(points) {
+		return points.map((point) => point.y);
+	}
+	scales(ctx) {
+		const points = this.points(), { left, right, top, bottom } = this.frame(ctx), inset = this.inset();
+		return {
+			x: this.axisScale(this.options.x, this.xValues(points), this.xKind, [left + inset, right - inset]),
+			y: this.axisScale(this.options.y, this.yValues(points), this.yKind, [bottom - inset, top + inset])
+		};
+	}
+	axisScale(column, values, kind, range) {
+		const [low = 0, high = 1] = extent(values);
+		const pad = (high - low) * .06 || Math.abs(high) * .1 || 1;
+		if (this.options.data?.find((row) => row[column] !== null && row[column] !== void 0)?.[column] instanceof Date) return scaleUtc([low - pad, high + pad], range);
+		if (kind === ScaleKind.Log) {
+			const start = low > 0 ? low / 1.12 : 1;
+			return Scales.continuous(kind).domain([start, high > low ? high * 1.12 : start * 10]).range(range);
+		}
+		const zero = this.options.domain === "zero";
+		return Scales.continuous(kind).domain([zero ? Math.min(0, low) : low - pad, zero ? Math.max(0, high + pad) : high + pad]).range(range).nice();
+	}
+	tickFormat(scale) {
+		return thinLogTicks(scale, super.tickFormat(scale));
+	}
+	plotMarks(ctx, axes) {
+		this.drawFrameGrid(ctx, axes);
+		const clean = this.points();
+		this.registerColors(ctx, clean);
+		this.plotPoints(ctx, axes, clean.map((point) => ({
+			...point,
+			px: axes.x(point.x),
+			py: axes.y(point.y)
+		})));
+	}
+	/** Fixes first-seen colour order to the data order, whatever order the marks draw in. */
+	registerColors(ctx, points) {
+		points.forEach((point) => this.hue(ctx, point));
+	}
+	drawFrameGrid(ctx, axes) {
+		const { left, right, top, bottom } = this.frame(ctx);
+		ctx.group("grid").selectAll("line").attr("x1", left).attr("x2", right);
+		const ticks = this.options.grid === false ? [] : axes.x.ticks(Math.min(this.xTicks(), Math.floor(ctx.plot.width / 80)));
+		ctx.marks("grid-x", "line", ticks.map(Number)).attr("stroke", ctx.theme.grid).attr("stroke-width", 1).attr("x1", (tick) => axes.x(tick)).attr("x2", (tick) => axes.x(tick)).attr("y1", top).attr("y2", bottom);
+		ctx.group("grid-x").lower();
+	}
+	/** Identity colour by group, in first-seen order. Registers the group for the legend. */
+	hue(ctx, point) {
+		return ctx.palette.color(point.group);
+	}
+	tooltip(ctx, point) {
+		const { x, y, size } = this.options;
+		const rows = [[x, this.show(point.x, x)], [y, this.show(point.y, y)]];
+		if (point.size) rows.push([size, point.size]);
+		return {
+			title: point.label || point.group,
+			color: this.hue(ctx, point),
+			rows
+		};
+	}
+	show(value, column) {
+		return this.options.data?.[0]?.[column] instanceof Date ? new Date(value).toISOString().slice(0, 10) : value;
+	}
+	/** Dots or symbols with the 2px surface ring, entering from zero size. */
+	drawDots(ctx, points, style = {}) {
+		const { name = "dots", radius = this.options.radius, fill = (point) => this.hue(ctx, point), marker = this.options.marker } = style;
+		const size = typeof radius === "function" ? radius : () => radius;
+		const stagger = Math.min(4, 400 / (points.length || 1));
+		if (marker === "circle") {
+			const dots = ctx.marks(name, "circle", points, scatterKey).attr("fill", fill).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+			ctx.set(dots, {
+				cx: (d) => d.px,
+				cy: (d) => d.py,
+				r: size
+			}, {
+				cx: (d) => d.px,
+				cy: (d) => d.py,
+				r: 0
+			}, stagger);
+			return ctx.hover(dots, (d) => this.tooltip(ctx, d));
+		}
+		const groups = [...new Set(points.map((point) => point.group))];
+		const kind = (point) => marker === "per-group" ? GROUP_SYMBOLS[groups.indexOf(point.group) % GROUP_SYMBOLS.length] : marker === "square" ? SymbolKind.Square : SymbolKind.Diamond;
+		const glyphs = ctx.marks(`${name}-glyphs`, "path", points, scatterKey).attr("fill", fill).attr("stroke", ctx.theme.surface).attr("stroke-width", 2).attr("d", (d) => symbol(Scales.symbol(kind(d)), Math.PI * size(d) ** 2 * 1.15)());
+		ctx.set(glyphs, { transform: (d) => `translate(${d.px},${d.py}) scale(1)` }, { transform: (d) => `translate(${d.px},${d.py}) scale(0)` }, stagger);
+		return ctx.hover(glyphs, (d) => this.tooltip(ctx, d));
+	}
+	/** Surface halo so a label stays readable over marks and grid. */
+	halo(labels, ctx) {
+		labels.attr("stroke", ctx.theme.surface).attr("stroke-width", 3).attr("paint-order", "stroke").attr("stroke-linejoin", "round");
+	}
+	/** Small sequential key for binned counts, placed where the data leaves room. */
+	drawCountKey(ctx, points, peak, shade = ctx.palette.sequential) {
+		const corner = this.quietCorner(ctx, points), cells = [
+			.2,
+			.4,
+			.6,
+			.8,
+			1
+		], cell = 14;
+		const start = corner.anchor === "start" ? corner.x : corner.x - cell * cells.length;
+		const swatches = ctx.marks("count-key", "rect", cells).attr("fill", (t) => shade(t));
+		ctx.set(swatches, {
+			x: (_, i) => start + i * cell,
+			y: corner.y - 4,
+			width: 13,
+			height: 6
+		});
+		const notes = ctx.marks("count-key-text", "text", [{
+			t: "1",
+			at: start,
+			anchor: "start"
+		}, {
+			t: String(peak),
+			at: start + cell * cells.length - 1,
+			anchor: "end"
+		}], (d) => d.anchor).attr("text-anchor", (d) => d.anchor).text((d) => d.t);
+		ctx.text(notes, 10, "muted");
+		ctx.set(notes, {
+			x: (d) => d.at,
+			y: corner.y + 14
+		});
+	}
+	/** The plot corner holding the fewest points: where annotations stay clear of the data. */
+	quietCorner(ctx, points) {
+		const { left, right, top, bottom } = this.frame(ctx);
+		const midX = (left + right) / 2, midY = (top + bottom) / 2;
+		return [
+			{
+				x: left + 8,
+				y: top + 14,
+				anchor: "start",
+				hits: (p) => p.px < midX && p.py < midY
+			},
+			{
+				x: right - 8,
+				y: top + 14,
+				anchor: "end",
+				hits: (p) => p.px >= midX && p.py < midY
+			},
+			{
+				x: left + 8,
+				y: bottom - 20,
+				anchor: "start",
+				hits: (p) => p.px < midX && p.py >= midY
+			},
+			{
+				x: right - 8,
+				y: bottom - 20,
+				anchor: "end",
+				hits: (p) => p.px >= midX && p.py >= midY
+			}
+		].map((corner) => ({
+			...corner,
+			count: points.filter(corner.hits).length
+		})).sort((a, b) => a.count - b.count)[0];
+	}
+};
+export { SCATTER_ALL, ScatterBase, ScatterDomain, ScatterMarker, ScatterScaling, scatterKey, scatterNumber, thinLogTicks };

package/dist/charts/scatter/ScatterGeometry.js

@@ -0,0 +1,95 @@
+import { Delaunay } from "d3-delaunay";
+// src/charts/scatter/ScatterGeometry.ts
+/** Computational geometry on screen coordinates, shared by the hull and tessellation charts. */
+var ScatterGeometry = class {
+	/** Unique Delaunay edges of the points; empty for fewer than two usable points. */
+	static delaunayEdges(points) {
+		if (points.length < 2) return [];
+		const { halfedges, triangles, hull } = Delaunay.from(points);
+		const edges = /* @__PURE__ */ new Map();
+		const add = (a, b) => {
+			if (!points[a] || !points[b] || a === b) return;
+			const key = a < b ? `${a}/${b}` : `${b}/${a}`;
+			if (!edges.has(key)) edges.set(key, {
+				a,
+				b,
+				length: Math.hypot(points[a][0] - points[b][0], points[a][1] - points[b][1])
+			});
+		};
+		for (let e = 0; e < halfedges.length; e++) add(triangles[e], triangles[e % 3 === 2 ? e - 2 : e + 1]);
+		if (!triangles.length) hull.forEach((vertex, i) => {
+			if (i) add(hull[i - 1], vertex);
+		});
+		return [...edges.values()];
+	}
+	/** Edges whose diametral circle holds no other point. */
+	static gabriel(points, edges) {
+		return edges.filter(({ a, b, length }) => {
+			const cx = (points[a][0] + points[b][0]) / 2, cy = (points[a][1] + points[b][1]) / 2;
+			return !points.some((point, i) => i !== a && i !== b && Math.hypot(point[0] - cx, point[1] - cy) < length / 2 - 1e-9);
+		});
+	}
+	/** Euclidean minimum spanning tree by Kruskal over the Delaunay edges. */
+	static spanningTree(points, edges) {
+		const parent = points.map((_, i) => i);
+		const find = (i) => parent[i] === i ? i : parent[i] = find(parent[i]);
+		return [...edges].sort((p, q) => p.length - q.length).filter(({ a, b }) => {
+			const ra = find(a), rb = find(b);
+			if (ra === rb) return false;
+			parent[ra] = rb;
+			return true;
+		});
+	}
+	/** Each point joined to its closest neighbour; a Delaunay edge always contains that neighbour. */
+	static nearestNeighbours(points, edges) {
+		const best = /* @__PURE__ */ new Map();
+		for (const edge of edges) for (const end of [edge.a, edge.b]) if ((best.get(end)?.length ?? Infinity) > edge.length) best.set(end, edge);
+		return [...new Set(best.values())];
+	}
+	/** Alpha-shape boundary loops: triangles with a small circumradius, minus interior edges. */
+	static concave(points, alpha) {
+		if (points.length < 3) return [];
+		const { triangles } = Delaunay.from(points);
+		const open = /* @__PURE__ */ new Map();
+		for (let t = 0; t < triangles.length; t += 3) {
+			const ids = [
+				triangles[t],
+				triangles[t + 1],
+				triangles[t + 2]
+			];
+			if (ids.some((id) => !points[id])) continue;
+			const [a, b, c] = ids.map((id) => points[id]);
+			const ab = Math.hypot(a[0] - b[0], a[1] - b[1]), bc = Math.hypot(b[0] - c[0], b[1] - c[1]), ca = Math.hypot(c[0] - a[0], c[1] - a[1]);
+			const doubled = Math.abs((b[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (b[1] - a[1]));
+			if (!doubled || ab * bc * ca / (2 * doubled) > alpha) continue;
+			for (const [p, q] of [
+				[ids[0], ids[1]],
+				[ids[1], ids[2]],
+				[ids[2], ids[0]]
+			]) {
+				if (open.delete(`${q}/${p}`)) continue;
+				open.set(`${p}/${q}`, [p, q]);
+			}
+		}
+		const next = /* @__PURE__ */ new Map();
+		for (const [p, q] of open.values()) next.set(p, [...next.get(p) ?? [], q]);
+		const loops = [];
+		while (next.size) {
+			const start = next.keys().next().value, loop = [];
+			let at = start;
+			while (at !== void 0 && next.has(at)) {
+				loop.push(points[at]);
+				const options = next.get(at), step = options.shift();
+				if (!options.length) next.delete(at);
+				at = step;
+			}
+			if (loop.length > 2) loops.push(loop);
+		}
+		return loops;
+	}
+	/** Vertices of a ring around a point; hulls of these give round offset outlines. */
+	static ring(center, radius, steps = 14) {
+		return Array.from({ length: steps }, (_, i) => [center[0] + radius * Math.cos(i / steps * Math.PI * 2), center[1] + radius * Math.sin(i / steps * Math.PI * 2)]);
+	}
+};
+export { ScatterGeometry };

package/dist/charts/scatter/ScatterPlot.js

@@ -0,0 +1,36 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { ScatterBase, ScatterDomain, ScatterMarker, ScatterScaling } from "./ScatterBase.js";
+// src/charts/scatter/ScatterPlot.ts
+/** The default for two measures: position shows the relationship, colour shows the group. */
+var ScatterPlot = class extends ScatterBase {
+	static meta = {
+		id: "scatter",
+		name: "Scatter plot",
+		family: ChartFamily.Relationship,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots two measures against each other to reveal correlation, clusters and outliers.",
+		tags: [
+			"xy",
+			"dot",
+			"correlation"
+		],
+		sample: (seed) => SampleData.points(seed),
+		variants: {
+			scaling: Object.values(ScatterScaling),
+			marker: [
+				ScatterMarker.Circle,
+				ScatterMarker.PerGroup,
+				ScatterMarker.Diamond,
+				ScatterMarker.Square
+			],
+			domain: [ScatterDomain.Tight, ScatterDomain.Zero]
+		},
+		valid: (v) => v.domain === ScatterDomain.Tight || v.scaling !== ScatterScaling.LogLog
+	};
+	plotPoints(ctx, _axes, points) {
+		this.drawDots(ctx, points);
+	}
+};
+export { ScatterPlot };

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,40 @@
+import { SCATTER_ALL, ScatterBase, ScatterDomain, ScatterMarker, ScatterScaling, scatterKey, scatterNumber, thinLogTicks } from "./ScatterBase.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 { CategoryScatterBase, CategorySort, CategorySummary } from "./CategoryScatterBase.js";
+import { JitterMethod, JitterPlot } from "./JitterPlot.js";
+import { MarginalKind, MarginalScatter, MarginalSides, MarginalSplit, ScatterBinRule } 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 { NeighbourScope, Tessellation, VoronoiScatter } from "./VoronoiScatter.js";
+import { ChangePath, ChangeScatter, ChangeStyle } from "./ChangeScatter.js";
+import { DropAxis, DropLineScatter, DropReference } from "./DropLineScatter.js";
+import { LabelLayout, LabelLeader, LabelSelection, LabelledScatter } from "./LabelledScatter.js";
+import { ParetoGoal, ParetoScatter, ParetoStep } from "./ParetoScatter.js";
+// src/charts/scatter/index.ts
+var scatterCatalog = [
+	ScatterPlot,
+	BubbleChart,
+	RegressionScatter,
+	JitterPlot,
+	QuadrantChart,
+	ConnectedScatter,
+	RugScatter,
+	MarginalScatter,
+	ErrorBarScatter,
+	EllipseScatter,
+	ConvexHullScatter,
+	VoronoiScatter,
+	LabelledScatter,
+	ParetoScatter,
+	DropLineScatter,
+	ChangeScatter
+];
+export { BubbleChart, BubblePlacement, CategoryScatterBase, CategorySort, CategorySummary, ChangePath, ChangeScatter, ChangeStyle, ConnectedArrows, ConnectedDotMode, ConnectedScatter, ConvexHullScatter, DropAxis, DropLineScatter, DropReference, EllipseEstimator, EllipseScatter, EllipseScope, ErrorBarScatter, ErrorDirection, ErrorSide, ErrorStyle, 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, ScatterDomain, ScatterGeometry, ScatterMarker, ScatterPlot, ScatterScaling, 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 };