@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/geoflows/WindMap.js

@@ -0,0 +1,293 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { FlowGeometry } from "./FlowGeometry.js";
+import { GeoFlowChart, GeoFlowFit, hasPlace, reading } from "./GeoFlowChart.js";
+import { GeoFlowProjection } from "./GeoFlowFrame.js";
+import { GeoFlowSample } from "./GeoFlowSample.js";
+import { bisectRight, scaleLinear } from "d3";
+// src/charts/geoflows/WindMap.ts
+/** How the vector field is drawn. */
+var WindMapMark = /* @__PURE__ */ function(WindMapMark) {
+	WindMapMark["Streamlines"] = "streamlines";
+	WindMapMark["Tapered"] = "tapered-streamlines";
+	WindMapMark["Curly"] = "curly-vectors";
+	WindMapMark["Arrows"] = "arrows";
+	WindMapMark["Barbs"] = "wind-barbs";
+	return WindMapMark;
+}({});
+var RADIANS = Math.PI / 180;
+var KNOTS = 1.944;
+var MAX_TRACE = 44;
+/** Regular-grid vector field with bilinear lookup. Longitude wraps when the grid circles the globe. */
+var WindField = class {
+	lons;
+	lats;
+	nodes = /* @__PURE__ */ new Map();
+	wraps;
+	peak;
+	constructor(rows) {
+		this.lons = [...new Set(rows.map((row) => row.place[0]))].sort((a, b) => a - b);
+		this.lats = [...new Set(rows.map((row) => row.place[1]))].sort((a, b) => a - b);
+		for (const { place, u, v } of rows) this.nodes.set(`${place[0]}/${place[1]}`, [u, v]);
+		this.wraps = this.lons.length > 2 && this.lons.at(-1) - this.lons[0] + (this.lons[1] - this.lons[0]) >= 359;
+		this.peak = GeoFlowChart.peakOf(rows, (row) => Math.hypot(row.u, row.v));
+	}
+	at([rawLon, lat]) {
+		const { lons, lats } = this;
+		const lon = (rawLon - lons[0] + 720) % 360 + lons[0];
+		const i = bisectRight(lons, lon) - 1, j = bisectRight(lats, lat) - 1;
+		if (i < 0 || j < 0 || j >= lats.length - 1 || i >= lons.length - 1 && !this.wraps) return [0, 0];
+		const x0 = lons[i], x1 = i + 1 < lons.length ? lons[i + 1] : lons[0] + 360, y0 = lats[j], y1 = lats[j + 1];
+		const fx = (lon - x0) / (x1 - x0), fy = (lat - y0) / (y1 - y0);
+		const node = (a, b) => this.nodes.get(`${a}/${b}`) ?? [0, 0];
+		const wrap = x1 >= lons[0] + 360 ? lons[0] : x1;
+		const [a, b, c, d] = [
+			node(x0, y0),
+			node(wrap, y0),
+			node(x0, y1),
+			node(wrap, y1)
+		];
+		const mix = (k) => (a[k] * (1 - fx) + b[k] * fx) * (1 - fy) + (c[k] * (1 - fx) + d[k] * fx) * fy;
+		return [mix(0), mix(1)];
+	}
+};
+/** Show a wind or current field: pass one row per regular grid node, with its eastward and northward components. */
+var WindMap = class extends GeoFlowChart {
+	static meta = {
+		id: "wind-map",
+		name: "Wind map",
+		family: ChartFamily.Geospatial,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Draws a gridded vector field over a map as streamlines, curly vectors, arrows or meteorological wind barbs.",
+		tags: [
+			"vector field",
+			"streamlines",
+			"currents"
+		],
+		sample: (seed) => GeoFlowSample.wind(seed),
+		variants: {
+			projection: [
+				GeoFlowProjection.NaturalEarth,
+				GeoFlowProjection.Orthographic,
+				GeoFlowProjection.Equirectangular,
+				GeoFlowProjection.Mercator
+			],
+			mark: [
+				"streamlines",
+				"tapered-streamlines",
+				"curly-vectors",
+				"arrows",
+				"wind-barbs"
+			],
+			spacing: [
+				26,
+				38,
+				20
+			]
+		}
+	};
+	parsed = null;
+	defaults() {
+		return {
+			...super.defaults(),
+			fit: GeoFlowFit.World,
+			lon: "lon",
+			lat: "lat",
+			u: "u",
+			v: "v",
+			mark: "streamlines",
+			spacing: 26
+		};
+	}
+	get grid() {
+		const { data, lon, lat, u, v } = this.options;
+		if (this.parsed?.data === data) return this.parsed;
+		const rows = (data ?? []).flatMap((row) => {
+			const place = [reading(row[lon]), reading(row[lat])], east = reading(row[u]), north = reading(row[v]);
+			return hasPlace(place) && Number.isFinite(east) && Number.isFinite(north) ? [{
+				place,
+				u: east,
+				v: north
+			}] : [];
+		});
+		return this.parsed = {
+			data,
+			rows,
+			field: new WindField(rows)
+		};
+	}
+	points() {
+		return this.grid.rows.map((row) => row.place);
+	}
+	/** Follows the wind from `start`, keeping a constant step on the page. */
+	trace(start, step, direction, limit, stop) {
+		const { field } = this.grid;
+		const line = [];
+		let [lon, lat] = start;
+		for (let i = 0; i < limit; i++) {
+			const [u, v] = field.at([lon, lat]), speed = Math.hypot(u, v);
+			if (speed < 1e-6) break;
+			lon += direction * u / speed * step / Math.max(.15, Math.cos(lat * RADIANS));
+			lat += direction * v / speed * step;
+			if (Math.abs(lat) > 85 || stop([lon, lat])) break;
+			line.push([lon, lat]);
+		}
+		return line;
+	}
+	/** Grid seeds across the plot, visited in a fixed scattered order so no direction is favoured. */
+	seeds(frame) {
+		const gap = this.options.spacing;
+		const seeds = [];
+		for (let y = gap / 2, row = 0; y < frame.height - gap / 2; y += gap, row++) for (let x = gap / 2 + row % 2 * (gap / 2); x < frame.width - gap / 2; x += gap) {
+			const place = frame.projection.invert?.([x, y]);
+			if (place && Number.isFinite(place[0]) && frame.at(place) && Math.abs(place[1]) < 82) seeds.push({
+				place,
+				at: [x, y],
+				rank: Math.abs(Math.sin(x * 12.9898 + y * 78.233) * 43758.5453) % 1
+			});
+		}
+		return seeds.sort((a, b) => a.rank - b.rank);
+	}
+	streamlines(frame, tapered, thick) {
+		const { spacing } = this.options;
+		const { field } = this.grid;
+		const step = 4 / (frame.projection.scale() * Math.PI / 180);
+		const cell = spacing * .6;
+		const taken = /* @__PURE__ */ new Set();
+		const slot = (place) => {
+			const at = frame.at(place);
+			return at ? `${Math.floor(at[0] / cell)}/${Math.floor(at[1] / cell)}` : null;
+		};
+		const glyphs = [];
+		this.seeds(frame).forEach((seed, key) => {
+			const home = slot(seed.place);
+			if (!home || taken.has(home)) return;
+			const blocked = (place) => {
+				const here = slot(place);
+				return !here || taken.has(here);
+			};
+			const line = [
+				...this.trace(seed.place, step, -1, MAX_TRACE, blocked).reverse(),
+				seed.place,
+				...this.trace(seed.place, step, 1, MAX_TRACE, blocked)
+			];
+			const run = this.runs(frame, line)[0];
+			if (!run || run.length < 8) return;
+			for (const place of line) {
+				const here = slot(place);
+				if (here) taken.add(here);
+			}
+			const speed = line.reduce((sum, place) => sum + Math.hypot(...field.at(place)), 0) / line.length;
+			const end = run.length - 1;
+			glyphs.push(tapered ? {
+				key,
+				speed,
+				filled: true,
+				d: FlowGeometry.ribbon(run, (t) => .5 + t * thick(speed))
+			} : {
+				key,
+				speed,
+				filled: false,
+				d: FlowGeometry.polyline(run),
+				head: FlowGeometry.arrow(run[end], run[Math.max(0, end - 2)], 6)
+			});
+		});
+		return glyphs;
+	}
+	curly(frame, thick) {
+		const { field, peak } = {
+			field: this.grid.field,
+			peak: this.grid.field.peak
+		};
+		const step = 2.5 / (frame.projection.scale() * Math.PI / 180);
+		return this.seeds(frame).flatMap((seed, key) => {
+			const speed = Math.hypot(...field.at(seed.place));
+			const run = this.runs(frame, [seed.place, ...this.trace(seed.place, step, 1, 3 + Math.round(speed / peak * (this.options.spacing / 1.6)), () => false)])[0];
+			return run && run.length > 2 ? [{
+				key,
+				speed,
+				filled: true,
+				d: FlowGeometry.ribbon(run, (t) => .5 + t * thick(speed))
+			}] : [];
+		});
+	}
+	/** Screen direction of the wind at a place, which depends on the projection. */
+	heading(frame, seed) {
+		const [u, v] = this.grid.field.at(seed.place), speed = Math.hypot(u, v);
+		if (speed < 1e-6) return null;
+		const ahead = frame.at([seed.place[0] + u / speed * .5 / Math.max(.15, Math.cos(seed.place[1] * RADIANS)), seed.place[1] + v / speed * .5]);
+		if (!ahead) return null;
+		const dx = ahead[0] - seed.at[0], dy = ahead[1] - seed.at[1], length = Math.hypot(dx, dy) || 1;
+		return [dx / length, dy / length];
+	}
+	arrows(frame) {
+		const { field, rows } = this.grid;
+		const gap = this.options.spacing;
+		return rows.length ? this.seeds(frame).flatMap((seed, key) => {
+			const heading = this.heading(frame, seed);
+			if (!heading) return [];
+			const speed = Math.hypot(...field.at(seed.place)), length = 4 + speed / field.peak * gap * .82;
+			const [dx, dy] = heading;
+			const tip = [seed.at[0] + dx * length * .5, seed.at[1] + dy * length * .5], tail = [seed.at[0] - dx * length * .5, seed.at[1] - dy * length * .5];
+			return [{
+				key,
+				speed,
+				filled: false,
+				d: FlowGeometry.polyline([tail, [tip[0] - dx * 3, tip[1] - dy * 3]]),
+				head: FlowGeometry.arrow(tip, tail, Math.min(6, 2.5 + length / 3))
+			}];
+		}) : [];
+	}
+	/** Station-model barbs: the staff points upwind, with a pennant for 50 kn, a line for 10 and a half line for 5. */
+	barbs(frame) {
+		const { field, rows } = this.grid;
+		const staff = Math.min(16, this.options.spacing * .72);
+		return rows.length ? this.seeds(frame).flatMap((seed, key) => {
+			const heading = this.heading(frame, seed);
+			if (!heading) return [];
+			const speed = Math.hypot(...field.at(seed.place)), [dx, dy] = heading, [nx, ny] = [-dy, dx];
+			let knots = Math.round(speed * KNOTS / 5) * 5, along = staff;
+			const [x, y] = seed.at;
+			const point = (back, side = 0) => `${(x - dx * back + nx * side).toFixed(1)},${(y - dy * back + ny * side).toFixed(1)}`;
+			let d = `M${point(0)}L${point(staff)}`;
+			while (knots >= 50) {
+				d += `M${point(along)}L${point(along - 4, 7)}L${point(along - 4)}Z`;
+				along -= 5;
+				knots -= 50;
+			}
+			while (knots >= 10) {
+				d += `M${point(along)}L${point(along + 2.5, 7)}`;
+				along -= 3;
+				knots -= 10;
+			}
+			if (knots >= 5) d += `M${point(along)}L${point(along + 1.25, 3.5)}`;
+			return [{
+				key,
+				speed,
+				filled: false,
+				d
+			}];
+		}) : [];
+	}
+	plotGeo(ctx, frame) {
+		const { mark } = this.options;
+		const { field, rows } = this.grid;
+		if (!rows.length) return;
+		const shade = scaleLinear([0, field.peak], [.32, 1]).clamp(true);
+		const color = (speed) => ctx.palette.sequential(shade(speed));
+		const thick = scaleLinear([0, field.peak], [1, 3.6]);
+		const glyphs = mark === "curly-vectors" ? this.curly(frame, thick) : mark === "arrows" ? this.arrows(frame) : mark === "wind-barbs" ? this.barbs(frame) : this.streamlines(frame, mark === "tapered-streamlines", thick);
+		const layer = this.clipped(ctx, "field", frame.path({ type: "Sphere" }) ?? "");
+		const lines = ctx.marks("wind", "path", glyphs, (d) => d.key, layer).attr("fill", (d) => d.filled ? color(d.speed) : "none").attr("stroke", (d) => d.filled ? "none" : color(d.speed)).attr("stroke-width", mark === "wind-barbs" ? 1.25 : 2).attr("stroke-linecap", "round").attr("stroke-linejoin", "round");
+		ctx.set(lines, { d: (d) => d.d }, { d: (d) => d.d });
+		if (mark === "streamlines") ctx.drawOn(lines);
+		ctx.hover(lines, (d) => ({
+			title: "Wind",
+			color: color(d.speed),
+			rows: [["Speed", `${d.speed.toFixed(1)} m/s`]]
+		}));
+		ctx.set(ctx.marks("heads", "path", glyphs.filter((d) => d.head), (d) => d.key, layer).attr("fill", (d) => color(d.speed)), { d: (d) => d.head });
+		this.keyRamp(ctx, "Speed, m/s", "0", field.peak.toFixed(0), (t) => ctx.palette.sequential(.32 + t * .68));
+	}
+};
+export { WindMap, WindMapMark };

package/dist/charts/geoflows/index.js

@@ -0,0 +1,47 @@
+import { GeoFlowProjection } from "./GeoFlowFrame.js";
+import { GeoFlowChart, GeoFlowFit } from "./GeoFlowChart.js";
+import { GeoFlowRoute, GeoLinkChart } from "./GeoLinkChart.js";
+import { ConnectionMap, ConnectionMapNode, ConnectionMapTopology } from "./ConnectionMap.js";
+import { DensityFlowBin, DensityFlowMap, DensityFlowScale } from "./DensityFlowMap.js";
+import { FlowMap, FlowMapShape } from "./FlowMap.js";
+import { GeoPointChart } from "./GeoPointChart.js";
+import { GeoBeeswarm, GeoBeeswarmLayout, GeoBeeswarmSize } from "./GeoBeeswarm.js";
+import { GeoSankey, GeoSankeyCurve, GeoSankeyNode, GeoSankeyOrder } from "./GeoSankey.js";
+import { GreatCircleArcMap, GreatCirclePath } from "./GreatCircleArcMap.js";
+import { HubSpokeDirection, HubSpokeMap, HubSpokeShape } from "./HubSpokeMap.js";
+import { IsochroneBreaks, IsochroneMap, IsochroneMethod, IsochroneStyle } from "./IsochroneMap.js";
+import { MeridianAggregate, MeridianBand, MeridianMap, MeridianMark } from "./MeridianMap.js";
+import { MigrationMap, MigrationMark, MigrationMode, MigrationNode } from "./MigrationMap.js";
+import { GeoTrackChart } from "./GeoTrackChart.js";
+import { MinardAlign, MinardFlowMap, MinardJoin } from "./MinardFlowMap.js";
+import { RingMap, RingMapOrder, RingMapSector } from "./RingMap.js";
+import { RouteMap, RouteMapOrder, RouteMapPath, RouteMapStops } from "./RouteMap.js";
+import { SmallMultipleMaps, SmallMultipleMark, SmallMultipleScale } from "./SmallMultipleMaps.js";
+import { SpiderHubPick, SpiderLine, SpiderMap } from "./SpiderMap.js";
+import { StormTrackMap, StormTrackMark, StormTrackScale } from "./StormTrackMap.js";
+import { TrajectoryEncoding, TrajectoryMap, TrajectoryMarker } from "./TrajectoryMap.js";
+import { VoronoiCellStyle, VoronoiMap, VoronoiSiteMark } from "./VoronoiMap.js";
+import { WindMap, WindMapMark } from "./WindMap.js";
+// src/charts/geoflows/index.ts
+var geoflowsCatalog = [
+	FlowMap,
+	ConnectionMap,
+	GreatCircleArcMap,
+	RouteMap,
+	TrajectoryMap,
+	VoronoiMap,
+	MeridianMap,
+	SpiderMap,
+	HubSpokeMap,
+	MigrationMap,
+	WindMap,
+	GeoSankey,
+	StormTrackMap,
+	IsochroneMap,
+	SmallMultipleMaps,
+	GeoBeeswarm,
+	RingMap,
+	DensityFlowMap,
+	MinardFlowMap
+];
+export { ConnectionMap, ConnectionMapNode, ConnectionMapTopology, DensityFlowBin, DensityFlowMap, DensityFlowScale, FlowMap, FlowMapShape, GeoBeeswarm, GeoBeeswarmLayout, GeoBeeswarmSize, GeoFlowChart, GeoFlowFit, GeoFlowProjection, GeoFlowRoute, GeoLinkChart, GeoPointChart, GeoSankey, GeoSankeyCurve, GeoSankeyNode, GeoSankeyOrder, GeoTrackChart, GreatCircleArcMap, GreatCirclePath, HubSpokeDirection, HubSpokeMap, HubSpokeShape, IsochroneBreaks, IsochroneMap, IsochroneMethod, IsochroneStyle, MeridianAggregate, MeridianBand, MeridianMap, MeridianMark, MigrationMap, MigrationMark, MigrationMode, MigrationNode, MinardAlign, MinardFlowMap, MinardJoin, RingMap, RingMapOrder, RingMapSector, RouteMap, RouteMapOrder, RouteMapPath, RouteMapStops, SmallMultipleMaps, SmallMultipleMark, SmallMultipleScale, SpiderHubPick, SpiderLine, SpiderMap, StormTrackMap, StormTrackMark, StormTrackScale, TrajectoryEncoding, TrajectoryMap, TrajectoryMarker, VoronoiCellStyle, VoronoiMap, VoronoiSiteMark, WindMap, WindMapMark, geoflowsCatalog };

package/dist/charts/geomaps/BivariateChoropleth.js

@@ -0,0 +1,117 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { GeoClasses, GeoClassification } from "./GeoClasses.js";
+import { GeoProjectionKind } from "./GeoProjection.js";
+import { GeoSamples } from "./GeoSamples.js";
+import { RegionMap } from "./RegionMap.js";
+import { color, interpolateLab, range } from "d3";
+// src/charts/geomaps/BivariateChoropleth.ts
+var GeoBivariateKey = /* @__PURE__ */ function(GeoBivariateKey) {
+	GeoBivariateKey["Square"] = "square";
+	GeoBivariateKey["Diamond"] = "diamond";
+	return GeoBivariateKey;
+}({});
+var CELL = 11;
+/** Show how two rates co-vary across space: each region is coloured by its class on both. */
+var BivariateChoropleth = class extends RegionMap {
+	static meta = {
+		id: "bivariate-choropleth",
+		name: "Bivariate choropleth",
+		family: ChartFamily.Geospatial,
+		dimension: Dimension.Two,
+		shape: DataShape.Geo,
+		description: "Crosses two classed variables into one colour matrix, to reveal where they rise together or diverge.",
+		tags: [
+			"map",
+			"two variables",
+			"matrix",
+			"correlation"
+		],
+		sample: (seed) => GeoSamples.regions(seed),
+		variants: {
+			projection: [
+				GeoProjectionKind.NaturalEarth,
+				GeoProjectionKind.EqualEarth,
+				GeoProjectionKind.Robinson,
+				GeoProjectionKind.Mollweide
+			],
+			classification: [
+				GeoClassification.Quantile,
+				GeoClassification.EqualInterval,
+				GeoClassification.NaturalBreaks
+			],
+			bins: [
+				3,
+				2,
+				4
+			],
+			keyShape: ["square", "diamond"]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			other: "other",
+			classification: GeoClassification.Quantile,
+			bins: 3,
+			keyShape: "square"
+		};
+	}
+	other(region) {
+		const raw = region.row[this.options.other];
+		return raw === null || raw === void 0 || !Number.isFinite(+raw) ? null : +raw;
+	}
+	matrix(ctx) {
+		const { divergingMid, divergingLow, divergingHigh } = ctx.theme, bins = this.options.bins;
+		const both = color(interpolateLab(divergingLow, divergingHigh)(.5)).darker(1.1).formatHex();
+		return (x, y) => {
+			const u = bins > 1 ? x / (bins - 1) : 0, v = bins > 1 ? y / (bins - 1) : 0;
+			return interpolateLab(interpolateLab(divergingMid, divergingLow)(u), interpolateLab(divergingHigh, both)(u))(v);
+		};
+	}
+	drawMap(ctx, frame) {
+		const { classification, bins } = this.options;
+		const regions = this.regions().map((region) => ({
+			...region,
+			other: this.other(region)
+		}));
+		const paired = regions.filter((region) => region.value !== null && region.other !== null);
+		const xs = new GeoClasses(paired.map((region) => region.value), classification, bins);
+		const ys = new GeoClasses(paired.map((region) => region.other), classification, bins);
+		const matrix = this.matrix(ctx), { theme } = ctx;
+		const shapes = ctx.marks("regions", "path", regions, (d) => d.key).attr("fill", (d) => d.value === null || d.other === null ? theme.grid : matrix(xs.bin(d.value), ys.bin(d.other))).attr("stroke", theme.surface).attr("stroke-width", this.hairline(ctx));
+		this.fill(ctx, shapes, (d) => frame.path(d.feature) ?? "");
+		ctx.hover(shapes, (d) => ({
+			title: d.name,
+			rows: [[this.options.value, d.value ?? "No data"], [this.options.other, d.other ?? "No data"]]
+		}));
+		this.drawMatrixKey(ctx, frame, matrix, xs, ys);
+	}
+	/** The 2-D key sits in the lower left corner of the map, with an arrow label per variable. */
+	drawMatrixKey(ctx, frame, matrix, xs, ys) {
+		const bins = this.options.bins, cells = range(xs.bins).flatMap((x) => range(ys.bins).map((y) => ({
+			x,
+			y
+		})));
+		const side = CELL * bins, diamond = this.options.keyShape === "diamond";
+		const reach = diamond ? side * Math.SQRT2 : side;
+		const anchor = diamond ? `translate(${reach / 2 + 2},${frame.height - reach - 2}) rotate(45)` : `translate(16,${frame.height - side - 16})`;
+		const key = ctx.nest(anchor, "matrix-key");
+		const across = (classes, limit) => side * (classes.breaks[limit] - classes.min) / (classes.max - classes.min);
+		key.marks("cells", "rect", cells, (d) => `${d.x}/${d.y}`).attr("x", (d) => across(xs, d.x)).attr("y", (d) => side - across(ys, d.y + 1)).attr("width", (d) => Math.max(1, across(xs, d.x + 1) - across(xs, d.x) - 1)).attr("height", (d) => Math.max(1, across(ys, d.y + 1) - across(ys, d.y) - 1)).attr("fill", (d) => matrix(d.x, d.y));
+		const labels = diamond ? [{
+			text: `${this.options.value} ↘  ${this.options.other} ↗`,
+			x: reach + 8,
+			y: frame.height - 3,
+			anchor: "start"
+		}] : [{
+			text: `${this.options.value} →`,
+			x: 16,
+			y: frame.height - 3,
+			anchor: "start"
+		}];
+		ctx.text(ctx.marks("key-label", "text", labels, (d) => d.text).attr("x", (d) => d.x).attr("y", (d) => d.y).attr("text-anchor", (d) => d.anchor).text((d) => d.text), 10, "muted");
+		const vertical = diamond ? [] : [`${this.options.other} →`];
+		ctx.text(ctx.marks("key-label-y", "text", vertical, (d) => d).attr("transform", `translate(11,${frame.height - 16}) rotate(-90)`).text((d) => d), 10, "muted");
+	}
+};
+export { BivariateChoropleth, GeoBivariateKey };

package/dist/charts/geomaps/BubbleMap.js

@@ -0,0 +1,115 @@
+import { ChartFamily, DataShape, Dimension, LegendPosition } from "../../core/enums.js";
+import { GeoLegend } from "./GeoLegend.js";
+import { GeoProjectionKind } from "./GeoProjection.js";
+import { GeoSamples } from "./GeoSamples.js";
+import { GeoGround, PointMap } from "./PointMap.js";
+import { descending, max, scaleSqrt } from "d3";
+// src/charts/geomaps/BubbleMap.ts
+/** Exact keeps true positions and lets bubbles overlap; Dodged separates them, with a leader back to each place. */
+var GeoBubblePlacement = /* @__PURE__ */ function(GeoBubblePlacement) {
+	GeoBubblePlacement["Exact"] = "exact";
+	GeoBubblePlacement["Dodged"] = "dodged";
+	return GeoBubblePlacement;
+}({});
+var CHAR = 6.2;
+var circle = (r) => `M${-r},0a${r},${r} 0 1,0 ${r * 2},0a${r},${r} 0 1,0 ${-r * 2},0Z`;
+/** Compare a quantity across named places, with bubble area for size and colour for group. */
+var BubbleMap = class extends PointMap {
+	static meta = {
+		id: "bubble-map",
+		name: "Bubble map",
+		family: ChartFamily.Geospatial,
+		dimension: Dimension.Two,
+		shape: DataShape.Geo,
+		description: "Sizes a bubble by value at each location, optionally coloured by group, to compare places directly.",
+		tags: [
+			"map",
+			"bubble",
+			"circles",
+			"cities"
+		],
+		sample: (seed) => GeoSamples.cities(seed),
+		variants: {
+			placement: ["exact", "dodged"],
+			labels: [true, false],
+			ground: [GeoGround.Filled, GeoGround.Lattice],
+			projection: [
+				GeoProjectionKind.NaturalEarth,
+				GeoProjectionKind.Robinson,
+				GeoProjectionKind.EqualEarth,
+				GeoProjectionKind.Mollweide,
+				GeoProjectionKind.Bertin
+			],
+			reach: [.08, .12]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			placement: "exact",
+			labels: true,
+			reach: .08,
+			legend: LegendPosition.Top,
+			graticule: false
+		};
+	}
+	place(sites, ctx, frame) {
+		const biggest = Math.min(ctx.plot.width, ctx.plot.height) * this.options.reach;
+		const radius = scaleSqrt([0, max(sites, (d) => Math.abs(d.value)) || 1], [0, biggest]);
+		const discs = sites.map((site) => ({
+			...site,
+			r: Math.max(3, radius(Math.abs(site.value))),
+			homeX: site.x,
+			homeY: site.y
+		})).sort((a, b) => descending(a.r, b.r));
+		return this.options.placement === "dodged" ? this.dodge(discs, frame, 1.5) : discs;
+	}
+	drawMap(ctx, frame) {
+		this.drawGround(ctx, frame);
+		const { value } = this.options, { theme, palette } = ctx;
+		const sites = this.sites(frame), discs = this.place(sites, ctx, frame);
+		const tint = (d) => palette.color(d.group ?? value);
+		const moved = discs.filter((d) => Math.hypot(d.x - d.homeX, d.y - d.homeY) > d.r * .5);
+		ctx.marks("leaders", "line", moved, (d) => d.key).attr("x1", (d) => d.homeX).attr("y1", (d) => d.homeY).attr("x2", (d) => d.x).attr("y2", (d) => d.y).attr("stroke", theme.inkMuted).attr("stroke-width", 1);
+		const bubbles = ctx.marks("bubbles", "circle", discs, (d) => d.key).attr("fill", tint).attr("fill-opacity", .78).attr("stroke", theme.surface).attr("stroke-width", 1.5);
+		ctx.set(bubbles, {
+			cx: (d) => d.x,
+			cy: (d) => d.y,
+			r: (d) => d.r
+		}, {
+			cx: (d) => d.x,
+			cy: (d) => d.y,
+			r: 0
+		}, 12);
+		ctx.hover(bubbles, (d) => ({
+			title: d.name,
+			color: tint(d),
+			rows: [[value, d.value]]
+		}));
+		this.drawLabels(ctx, discs);
+		const top = max(discs, (d) => Math.abs(d.value)) ?? 0, big = max(discs, (d) => d.r) ?? 0;
+		GeoLegend.nested(ctx, frame, top ? [{
+			value: top,
+			radius: big
+		}, {
+			value: Math.round(top / 4),
+			radius: big / 2
+		}] : [], circle);
+	}
+	drawLabels(ctx, discs) {
+		const taken = [];
+		const labels = !this.options.labels ? [] : discs.slice(0, 8).filter((d) => {
+			const width = d.name.length * CHAR, x0 = d.x - width / 2, y0 = d.y - 7;
+			if (taken.some(([x, y, w, h]) => x0 < x + w && x0 + width > x && y0 < y + h && y0 + 13 > y)) return false;
+			taken.push([
+				x0,
+				y0,
+				width,
+				13
+			]);
+			return true;
+		});
+		this.halo(ctx, ctx.text(ctx.marks("labels", "text", labels, (d) => d.key).attr("x", (d) => d.x).attr("y", (d) => d.y + 4).attr("text-anchor", "middle").attr("pointer-events", "none").text((d) => d.name), 11, "ink"));
+	}
+};
+export { BubbleMap, GeoBubblePlacement };