@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/geomaps/GeoProjection.js

@@ -0,0 +1,159 @@
+import { geoAlbers, geoAlbersUsa, geoAzimuthalEqualArea, geoAzimuthalEquidistant, geoConicConformal, geoConicEquidistant, geoEqualEarth, geoEquirectangular, geoGnomonic, geoGraticule, geoMercator, geoNaturalEarth1, geoOrthographic, geoStereographic } from "d3";
+import { geoAitoff, geoArmadillo, geoBerghaus, geoBertin1953, geoBonne, geoCylindricalEqualArea, geoEckert4, geoEckert6, geoHammer, geoHealpix, geoInterruptedHomolosine, geoInterruptedMollweide, geoInterruptedSinusoidal, geoKavrayskiy7, geoLoximuthal, geoMiller, geoMollweide, geoNaturalEarth2, geoPatterson, geoPeirceQuincuncial, geoPolyconic, geoPolyhedralButterfly, geoPolyhedralWaterman, geoRobinson, geoSatellite, geoSinusoidal, geoTimes, geoVanDerGrinten, geoWagner6, geoWinkel3 } from "d3-geo-projection";
+// src/charts/geomaps/GeoProjection.ts
+var GeoProjectionKind = /* @__PURE__ */ function(GeoProjectionKind) {
+	GeoProjectionKind["NaturalEarth"] = "natural-earth";
+	GeoProjectionKind["NaturalEarth2"] = "natural-earth-2";
+	GeoProjectionKind["EqualEarth"] = "equal-earth";
+	GeoProjectionKind["Robinson"] = "robinson";
+	GeoProjectionKind["WinkelTripel"] = "winkel-tripel";
+	GeoProjectionKind["Mollweide"] = "mollweide";
+	GeoProjectionKind["Hammer"] = "hammer";
+	GeoProjectionKind["Aitoff"] = "aitoff";
+	GeoProjectionKind["Eckert4"] = "eckert-4";
+	GeoProjectionKind["Eckert6"] = "eckert-6";
+	GeoProjectionKind["Wagner6"] = "wagner-6";
+	GeoProjectionKind["Kavrayskiy7"] = "kavrayskiy-7";
+	GeoProjectionKind["Patterson"] = "patterson";
+	GeoProjectionKind["Times"] = "times";
+	GeoProjectionKind["Sinusoidal"] = "sinusoidal";
+	GeoProjectionKind["Loximuthal"] = "loximuthal";
+	GeoProjectionKind["Equirectangular"] = "equirectangular";
+	GeoProjectionKind["Mercator"] = "mercator";
+	GeoProjectionKind["Miller"] = "miller";
+	GeoProjectionKind["GallPeters"] = "gall-peters";
+	GeoProjectionKind["Bertin"] = "bertin-1953";
+	GeoProjectionKind["VanDerGrinten"] = "van-der-grinten";
+	GeoProjectionKind["InterruptedHomolosine"] = "interrupted-homolosine";
+	GeoProjectionKind["InterruptedMollweide"] = "interrupted-mollweide";
+	GeoProjectionKind["InterruptedSinusoidal"] = "interrupted-sinusoidal";
+	GeoProjectionKind["Butterfly"] = "butterfly";
+	GeoProjectionKind["Waterman"] = "waterman";
+	GeoProjectionKind["Berghaus"] = "berghaus";
+	GeoProjectionKind["Healpix"] = "healpix";
+	GeoProjectionKind["Quincuncial"] = "peirce-quincuncial";
+	GeoProjectionKind["Armadillo"] = "armadillo";
+	GeoProjectionKind["Orthographic"] = "orthographic";
+	GeoProjectionKind["Stereographic"] = "stereographic";
+	GeoProjectionKind["AzimuthalEqualArea"] = "azimuthal-equal-area";
+	GeoProjectionKind["AzimuthalEquidistant"] = "azimuthal-equidistant";
+	GeoProjectionKind["Gnomonic"] = "gnomonic";
+	GeoProjectionKind["Satellite"] = "satellite";
+	GeoProjectionKind["Albers"] = "albers";
+	GeoProjectionKind["ConicConformal"] = "conic-conformal";
+	GeoProjectionKind["ConicEquidistant"] = "conic-equidistant";
+	GeoProjectionKind["Bonne"] = "bonne";
+	GeoProjectionKind["Polyconic"] = "polyconic";
+	GeoProjectionKind["AlbersUsa"] = "albers-usa";
+	return GeoProjectionKind;
+}({});
+/** What the map is fitted to. `Auto` shows the whole sphere for world-spanning data and zooms to anything smaller. */
+var GeoFraming = /* @__PURE__ */ function(GeoFraming) {
+	GeoFraming["Auto"] = "auto";
+	GeoFraming["Sphere"] = "sphere";
+	GeoFraming["Data"] = "data";
+	return GeoFraming;
+}({});
+var K = GeoProjectionKind;
+var SATELLITE = 1.7;
+var FACTORIES = {
+	[K.NaturalEarth]: geoNaturalEarth1,
+	[K.NaturalEarth2]: geoNaturalEarth2,
+	[K.EqualEarth]: geoEqualEarth,
+	[K.Robinson]: geoRobinson,
+	[K.WinkelTripel]: geoWinkel3,
+	[K.Mollweide]: geoMollweide,
+	[K.Hammer]: geoHammer,
+	[K.Aitoff]: geoAitoff,
+	[K.Eckert4]: geoEckert4,
+	[K.Eckert6]: geoEckert6,
+	[K.Wagner6]: geoWagner6,
+	[K.Kavrayskiy7]: geoKavrayskiy7,
+	[K.Patterson]: geoPatterson,
+	[K.Times]: geoTimes,
+	[K.Sinusoidal]: geoSinusoidal,
+	[K.Loximuthal]: geoLoximuthal,
+	[K.Equirectangular]: geoEquirectangular,
+	[K.Mercator]: geoMercator,
+	[K.Miller]: geoMiller,
+	[K.GallPeters]: () => geoCylindricalEqualArea().parallel(45),
+	[K.Bertin]: geoBertin1953,
+	[K.VanDerGrinten]: geoVanDerGrinten,
+	[K.InterruptedHomolosine]: geoInterruptedHomolosine,
+	[K.InterruptedMollweide]: geoInterruptedMollweide,
+	[K.InterruptedSinusoidal]: geoInterruptedSinusoidal,
+	[K.Butterfly]: geoPolyhedralButterfly,
+	[K.Waterman]: geoPolyhedralWaterman,
+	[K.Berghaus]: geoBerghaus,
+	[K.Healpix]: () => geoHealpix().lobes(2),
+	[K.Quincuncial]: geoPeirceQuincuncial,
+	[K.Armadillo]: () => geoArmadillo().parallel(20),
+	[K.Orthographic]: () => geoOrthographic().rotate([-15, -25]).clipAngle(90),
+	[K.Stereographic]: () => geoStereographic().rotate([-15, -25]).clipAngle(120),
+	[K.AzimuthalEqualArea]: () => geoAzimuthalEqualArea().rotate([-15, -25]),
+	[K.AzimuthalEquidistant]: () => geoAzimuthalEquidistant().rotate([-15, -25]),
+	[K.Gnomonic]: () => geoGnomonic().rotate([-15, -35]).clipAngle(62),
+	[K.Satellite]: () => geoSatellite().distance(SATELLITE).tilt(20).rotate([-15, -35]).clipAngle(Math.acos(1 / SATELLITE) * 180 / Math.PI - .001),
+	[K.Albers]: () => geoAlbers().rotate([-15, 0]).center([0, 0]).parallels([20, 60]),
+	[K.ConicConformal]: () => geoConicConformal().rotate([-15, 0]).center([0, 0]).parallels([30, 60]).clipAngle(120),
+	[K.ConicEquidistant]: () => geoConicEquidistant().rotate([-15, 0]).center([0, 0]).parallels([20, 60]),
+	[K.Bonne]: () => geoBonne().parallel(45),
+	[K.Polyconic]: geoPolyconic,
+	[K.AlbersUsa]: () => geoAlbersUsa()
+};
+var AZIMUTHAL = /* @__PURE__ */ new Set([
+	K.Orthographic,
+	K.Stereographic,
+	K.AzimuthalEqualArea,
+	K.AzimuthalEquidistant,
+	K.Gnomonic,
+	K.Satellite
+]);
+var CONIC = /* @__PURE__ */ new Set([
+	K.Albers,
+	K.ConicConformal,
+	K.ConicEquidistant
+]);
+var UNBOUNDED_POLES = /* @__PURE__ */ new Set([K.Mercator]);
+var LOBED = /* @__PURE__ */ new Set([
+	K.InterruptedHomolosine,
+	K.InterruptedMollweide,
+	K.InterruptedSinusoidal,
+	K.Butterfly,
+	K.Waterman,
+	K.Healpix,
+	K.Armadillo
+]);
+/** Builds, centres and fits d3 projections from `GeoProjectionKind`. */
+var GeoProjections = class GeoProjections {
+	/** Every projection that shows the whole world, for atlases and projection pickers. */
+	static world = Object.values(GeoProjectionKind).filter((kind) => kind !== K.AlbersUsa && kind !== K.ConicConformal);
+	static create(kind) {
+		return typeof kind === "string" ? FACTORIES[kind]() : kind;
+	}
+	/** True when the poles run to infinity, so the view must be clipped to a band. */
+	static unbounded(kind) {
+		return typeof kind === "string" && UNBOUNDED_POLES.has(kind);
+	}
+	/** True when polygons crossing a lobe boundary can leak: d3 fills the gap, so the map is masked to the sphere. */
+	static lobed(kind) {
+		return typeof kind === "string" && LOBED.has(kind);
+	}
+	/** Geometry to fit for a world view: the sphere, or a latitude band for unbounded projections. */
+	static outline(kind) {
+		if (this.unbounded(kind)) return geoGraticule().extent([[-180, -62], [180, 84]]).outline();
+		return { type: "Sphere" };
+	}
+	static rotate(projection, rotation) {
+		projection.rotate?.(rotation);
+	}
+	/** Centre on a lon/lat box so regional maps stay undistorted and antimeridian-safe. */
+	static center(projection, kind, [[west, south], [east, north]]) {
+		if (typeof kind !== "string" || kind === K.AlbersUsa) return;
+		const lon = (west + (east < west ? east + 360 : east)) / 2, lat = (south + north) / 2;
+		if (AZIMUTHAL.has(kind)) return GeoProjections.rotate(projection, [-lon, -lat]);
+		GeoProjections.rotate(projection, [-lon, 0]);
+		if (CONIC.has(kind)) projection.parallels([south + (north - south) / 6, north - (north - south) / 6]);
+	}
+};
+export { GeoFraming, GeoProjectionKind, GeoProjections };

package/dist/charts/geomaps/GeoSamples.js

@@ -0,0 +1,139 @@
+import { GeoAtlas } from "../../data/GeoAtlas.js";
+import { SampleData } from "../../data/SampleData.js";
+import { GeoLand } from "./GeoLand.js";
+import { geoArea, geoCentroid } from "d3";
+// src/charts/geomaps/GeoSamples.ts
+var continent = (lon, lat) => {
+	if (lon < -30) return lat > 13 ? "North America" : "South America";
+	if (lon < 60) {
+		if (lat > 36) return "Europe";
+		return lon > 36 && lat > 12 ? "Asia" : "Africa";
+	}
+	return lon > 110 && lat < -10 ? "Oceania" : "Asia";
+};
+/** Stable noise for an id, so a shape keeps its demo value between draws. */
+var jitter = (id, seed) => {
+	let hash = seed * 2654435761;
+	for (const char of id) hash = Math.imul(hash ^ char.charCodeAt(0), 16777619);
+	return (hash >>> 0) % 1e3 / 1e3;
+};
+/** Reshapes `SampleData` into spatially coherent demo data, so sample maps show real geographic pattern. */
+var GeoSamples = class GeoSamples {
+	/** Gives any shapes a smooth demo `value`, 0 to 100. */
+	static shaded(collection, seed) {
+		return {
+			...collection,
+			demo: true,
+			features: collection.features.map((feature) => {
+				const [lon, lat] = geoCentroid(feature);
+				const wave = .5 + .5 * Math.sin(lon / 7 + seed) * Math.cos(lat / 6 - seed);
+				return {
+					...feature,
+					properties: {
+						...feature.properties,
+						value: Math.round(78 * wave + 22 * jitter(String(feature.id), seed))
+					}
+				};
+			})
+		};
+	}
+	/** The 50 states and DC with demo values. */
+	static usStates(seed) {
+		const { states } = GeoAtlas;
+		return GeoSamples.shaded({
+			...states,
+			features: states.features.filter((state) => +state.id <= 56)
+		}, seed);
+	}
+	/** World regions with `value`, `other` and `group`; Antarctica has no data, as real datasets rarely do. */
+	static regions(seed) {
+		const world = SampleData.world(seed), noise = SampleData.world(seed + 7);
+		return {
+			...world,
+			features: world.features.map((feature, i) => {
+				const [lon, lat] = geoCentroid(feature);
+				const north = Math.min(1, Math.abs(lat) / 66), wave = .5 + .5 * Math.sin(lon / 38 + seed);
+				const known = feature.properties?.name !== "Antarctica";
+				return {
+					...feature,
+					properties: {
+						...feature.properties,
+						value: known ? Math.round(64 * north + 22 * wave + .14 * feature.properties.value) : null,
+						other: known ? Math.round(56 * wave + 30 * (1 - north) + .14 * noise.features[i].properties.value) : null,
+						group: known ? continent(lon, lat) : null
+					}
+				};
+			})
+		};
+	}
+	/** Regions without Antarctica, for maps that give every region equal weight. */
+	static inhabited(seed) {
+		const regions = this.regions(seed);
+		return {
+			...regions,
+			features: regions.features.filter((feature) => feature.properties?.value !== null)
+		};
+	}
+	/** `regions` as totals rather than rates: `value` grows with land area, as counts do. */
+	static totals(seed) {
+		const regions = this.regions(seed);
+		return {
+			...regions,
+			features: regions.features.map((feature) => {
+				const rate = feature.properties?.value;
+				return {
+					...feature,
+					properties: {
+						...feature.properties,
+						value: rate === null ? null : Math.max(.1, +(rate * 30 * geoArea(feature) ** .75).toFixed(1))
+					}
+				};
+			})
+		};
+	}
+	/** Twenty cities, tagged by continent. */
+	static cities(seed) {
+		return SampleData.cities(seed).map((city) => ({
+			...city,
+			group: continent(+city.lon, +city.lat)
+		}));
+	}
+	/** Points clustered around the cities and kept on land; `value` falls away from each centre. */
+	static scatter(seed, count) {
+		const cities = SampleData.cities(seed), world = GeoLand.world;
+		return SampleData.points(seed, count * 4, 3).flatMap((point, i) => {
+			const city = cities[i * 7 % cities.length];
+			const dx = (+point.x - 20 - i % 3 * 22) * 1.3, dy = (+point.y - .8 * +point.x - 10) * 1.2;
+			const lon = +city.lon + dx, lat = +city.lat + dy;
+			if (!GeoLand.at(world, lon, lat)) return [];
+			const fall = Math.exp(-Math.hypot(dx, dy) / 12);
+			return [{
+				name: `${city.name} ${i + 1}`,
+				lon: +lon.toFixed(2),
+				lat: +lat.toFixed(2),
+				value: Math.round(4 + (+city.value + +point.size) * fall),
+				group: point.group
+			}];
+		}).slice(0, count);
+	}
+	/** Long-form `{ name, lon, lat, series, value }`: one row per city and series. */
+	static cityParts(seed) {
+		const parts = SampleData.categories(seed, 12, 4);
+		return SampleData.cities(seed).flatMap((city, c) => [
+			0,
+			1,
+			2,
+			3
+		].map((s) => {
+			const part = parts[(c * 4 + s) % parts.length];
+			return {
+				name: city.name,
+				lon: city.lon,
+				lat: city.lat,
+				series: part.series,
+				value: Math.round(+part.value * +city.value / 40)
+			};
+		}));
+	}
+};
+export { GeoSamples };

package/dist/charts/geomaps/GeoViewport.js

@@ -0,0 +1,148 @@
+import { ZoomControls } from "../../core/ZoomControls.js";
+import { zoom, zoomIdentity, zoomTransform } from "d3";
+// src/charts/geomaps/GeoViewport.ts
+var SCALE_VAR = "--geo-unzoom";
+/** Marks placed by translation. Groups opt in with `data-geo-pin`, since most groups are layouts rather than symbols. */
+var PLACED = "path[transform^=\"translate(\"],circle[transform^=\"translate(\"],rect[transform^=\"translate(\"],text[transform^=\"translate(\"],use[transform^=\"translate(\"],[data-geo-pin]";
+var TRANSLATE = /^translate\(\s*(-?[\d.e+-]+)[ ,]+(-?[\d.e+-]+)?\s*\)/;
+var unpinnedParent = function() {
+	return !this.closest("clipPath") && !this.parentElement?.closest("[data-geo-pin]");
+};
+var clips = 0;
+/** Pan, zoom and fit for a map: gesture handling, on-screen controls and the transformed layer. */
+var GeoViewport = class {
+	#host;
+	#clipId = `geo-view-${++clips}`;
+	#behavior = null;
+	#root = null;
+	#view = null;
+	#bound = null;
+	#active = false;
+	#setup = null;
+	#size = "";
+	constructor(host) {
+		this.#host = host;
+	}
+	get scale() {
+		return this.transform.k;
+	}
+	get transform() {
+		const node = this.#root?.node();
+		return node ? zoomTransform(node) : zoomIdentity;
+	}
+	/** Prepares the layer marks draw into, and returns the context for it. */
+	attach(ctx, setup) {
+		if (setup.enabled !== this.#active) {
+			ctx.root.selectAll("*").remove();
+			if (!setup.enabled) ctx.root.on(".zoom", null).property("__zoom", zoomIdentity);
+			this.#bound = null;
+			this.#active = setup.enabled;
+		}
+		this.#setup = setup;
+		if (!setup.enabled) return ctx;
+		const { width, height, limits } = setup, node = ctx.root.node();
+		const size = `${width}x${height}`;
+		if (this.#size && size !== this.#size) node.__zoom = zoomIdentity;
+		this.#size = size;
+		this.#root = ctx.root;
+		const behavior = this.#behavior ??= zoom().on("start", () => {
+			if (this.#setup?.pinned && !this.#setup.semantic) this.#pin();
+		}).on("zoom", ({ transform }) => this.#moved(transform, false)).on("end", ({ transform }) => this.#moved(transform, true));
+		behavior.extent([[0, 0], [width, height]]).scaleExtent(limits.scale).translateExtent(limits.pan);
+		if (this.#bound !== node) {
+			ctx.root.call(behavior);
+			this.#bound = node;
+		}
+		ctx.marks("zoom-hit", "rect", [0]).attr("width", width).attr("height", height).attr("fill", "transparent").style("cursor", "grab");
+		ctx.marks("view-clip", "clipPath", [0]).attr("id", this.#clipId).selectAll("rect").data([0]).join("rect").attr("width", width).attr("height", height);
+		this.#view = ctx.group("view-frame").attr("clip-path", `url(#${this.#clipId})`).call((frame) => ctx.group("view", frame)).select(":scope > g.m-view");
+		return ctx.within(this.#view);
+	}
+	/** Call after drawing: readies the new marks for zooming and draws the controls on `ctx`. */
+	finish(ctx) {
+		if (!this.#active || !this.#view) return;
+		const view = this.#view, { pinned, semantic } = this.#setup;
+		view.selectAll("path,line,rect,circle,ellipse,polyline,polygon").attr("vector-effect", "non-scaling-stroke");
+		if (pinned && !semantic) this.#pin();
+		this.#apply(this.transform);
+		this.#controls(ctx);
+	}
+	/**
+	* Holds dots, symbols and labels at their drawn size while the map scales. The browser applies
+	* `scale` outside the `transform` attribute, so each mark scales about its own position.
+	*/
+	#pin() {
+		const unzoom = `var(${SCALE_VAR}, 1)`;
+		this.#view.selectAll("circle:not([transform]),text:not([transform])").filter(unpinnedParent).style("transform-box", "fill-box").style("transform-origin", "center").style("scale", unzoom);
+		this.#view.selectAll(PLACED).filter(unpinnedParent).each(function() {
+			const [, x, y] = TRANSLATE.exec(this.getAttribute("transform") ?? "") ?? [];
+			if (x === void 0) return;
+			this.style.transformOrigin = `${x}px ${y ?? 0}px`;
+			this.style.setProperty("scale", unzoom);
+		});
+	}
+	zoomIn() {
+		return this.#scaleBy(2);
+	}
+	zoomOut() {
+		return this.#scaleBy(.5);
+	}
+	reset(smooth = this.#setup?.smooth) {
+		return this.#go(zoomIdentity, smooth);
+	}
+	/** Frames a pixel box, as measured in the unzoomed map. */
+	fit([[x0, y0], [x1, y1]], smooth = this.#setup?.smooth) {
+		const setup = this.#setup;
+		if (!setup || !Number.isFinite(x0 + y0 + x1 + y1)) return Promise.resolve();
+		const { width, height, limits: { scale: [low, high] } } = setup;
+		const k = Math.max(low, Math.min(high, .88 / Math.max((x1 - x0) / width, (y1 - y0) / height)));
+		return this.#go(zoomIdentity.translate(width / 2, height / 2).scale(k).translate(-(x0 + x1) / 2, -(y0 + y1) / 2), smooth);
+	}
+	#scaleBy(factor) {
+		const { k } = this.transform, setup = this.#setup;
+		if (!setup) return Promise.resolve();
+		const { width, height, limits: { scale: [low, high] } } = setup, next = Math.max(low, Math.min(high, k * factor));
+		const [cx, cy] = this.transform.invert([width / 2, height / 2]);
+		return this.#go(zoomIdentity.translate(width / 2, height / 2).scale(next).translate(-cx, -cy), setup.smooth);
+	}
+	async #go(transform, smooth) {
+		const root = this.#root, behavior = this.#behavior;
+		if (!root || !behavior) return;
+		if (!smooth) {
+			root.call(behavior.transform, transform);
+			return;
+		}
+		await root.transition().duration(460).call(behavior.transform, transform).end().catch(() => void 0);
+	}
+	#apply({ x, y, k }) {
+		if (this.#setup?.semantic) return;
+		this.#view?.attr("transform", `translate(${x},${y}) scale(${k})`).style(SCALE_VAR, 1 / k);
+	}
+	#moved(transform, settled) {
+		this.#apply(transform);
+		this.#host.viewMoved(transform, settled);
+	}
+	#controls(ctx) {
+		ZoomControls.draw(ctx, this.#setup.width, [
+			{
+				key: "in",
+				glyph: "+",
+				label: "Zoom in",
+				run: () => void this.zoomIn()
+			},
+			{
+				key: "out",
+				glyph: "−",
+				label: "Zoom out",
+				run: () => void this.zoomOut()
+			},
+			{
+				key: "reset",
+				glyph: "⟲",
+				label: "Reset view",
+				run: () => void this.reset()
+			}
+		]);
+	}
+};
+export { GeoViewport };

package/dist/charts/geomaps/GraticuleMap.js

@@ -0,0 +1,42 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { GeoProjections } from "./GeoProjection.js";
+import { RegionMap } from "./RegionMap.js";
+// src/charts/geomaps/GraticuleMap.ts
+/** The projection atlas: the world's grid and coastlines, for choosing or teaching a projection. */
+var GraticuleMap = class extends RegionMap {
+	static meta = {
+		id: "graticule-map",
+		name: "Graticule map",
+		family: ChartFamily.Geospatial,
+		dimension: Dimension.Two,
+		shape: DataShape.Geo,
+		description: "Draws meridians, parallels and land in any of 41 projections, to compare how each distorts the globe.",
+		tags: [
+			"map",
+			"projection",
+			"atlas",
+			"grid",
+			"reference"
+		],
+		sample: (seed) => SampleData.world(seed),
+		variants: {
+			projection: GeoProjections.world,
+			graticuleStep: [
+				30,
+				15,
+				10
+			]
+		}
+	};
+	target() {
+		return null;
+	}
+	drawMap(ctx, frame) {
+		const { theme } = ctx;
+		const shapes = ctx.marks("regions", "path", this.regions(), (d) => d.key).attr("fill", theme.axis).attr("stroke", theme.surface).attr("stroke-width", this.hairline(ctx));
+		this.fill(ctx, shapes, (d) => frame.path(d.feature) ?? "", .75);
+		ctx.hover(shapes, (d) => ({ title: d.name }));
+	}
+};
+export { GraticuleMap };

package/dist/charts/geomaps/HatchedChoropleth.js

@@ -0,0 +1,110 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { GeoClasses, GeoClassification } from "./GeoClasses.js";
+import { GeoLegend } from "./GeoLegend.js";
+import { GeoProjectionKind } from "./GeoProjection.js";
+import { GeoSamples } from "./GeoSamples.js";
+import { RegionMap } from "./RegionMap.js";
+import { range, scaleLinear } from "d3";
+// src/charts/geomaps/HatchedChoropleth.ts
+var GeoHatch = /* @__PURE__ */ function(GeoHatch) {
+	GeoHatch["Diagonal"] = "diagonal";
+	GeoHatch["Horizontal"] = "horizontal";
+	GeoHatch["Vertical"] = "vertical";
+	GeoHatch["Crosshatch"] = "crosshatch";
+	GeoHatch["Stipple"] = "stipple";
+	return GeoHatch;
+}({});
+var patterns = 0;
+/** Class patterns instead of colour, for print, greyscale and colour-blind-safe reading: denser means higher. */
+var HatchedChoropleth = class extends RegionMap {
+	static meta = {
+		id: "hatched-choropleth",
+		name: "Hatched choropleth",
+		family: ChartFamily.Geospatial,
+		dimension: Dimension.Two,
+		shape: DataShape.Geo,
+		description: "Fills regions with line or dot patterns whose density rises with value, for print and monochrome maps.",
+		tags: [
+			"map",
+			"pattern",
+			"monochrome",
+			"print",
+			"engraved"
+		],
+		sample: (seed) => GeoSamples.regions(seed),
+		variants: {
+			hatch: [
+				"diagonal",
+				"horizontal",
+				"vertical",
+				"crosshatch",
+				"stipple"
+			],
+			classification: [
+				GeoClassification.Quantile,
+				GeoClassification.EqualInterval,
+				GeoClassification.NaturalBreaks
+			],
+			bins: [
+				4,
+				3,
+				5
+			],
+			projection: [
+				GeoProjectionKind.NaturalEarth,
+				GeoProjectionKind.Robinson,
+				GeoProjectionKind.EqualEarth
+			]
+		}
+	};
+	patternId = `geo-hatch-${++patterns}`;
+	defaults() {
+		return {
+			...super.defaults(),
+			hatch: "diagonal",
+			classification: GeoClassification.Quantile,
+			bins: 4,
+			graticule: false
+		};
+	}
+	keyHeight() {
+		return GeoLegend.height;
+	}
+	tile(spacing) {
+		const s = spacing, mid = s / 2;
+		switch (this.options.hatch) {
+			case "horizontal": return `M0,${mid}H${s}`;
+			case "vertical": return `M${mid},0V${s}`;
+			case "crosshatch": return `M0,${mid}H${s}M${mid},0V${s}`;
+			case "stipple": return `M${mid},${mid}h0.01`;
+			default: return `M0,${s}L${s},0M${-mid},${mid}L${mid},${-mid}M${mid},${s + mid}L${s + mid},${mid}`;
+		}
+	}
+	drawPatterns(ctx, classes) {
+		const spacings = scaleLinear([0, Math.max(1, classes.bins - 1)], [9, 3]);
+		const tiles = ctx.marks("patterns", "pattern", range(classes.bins)).attr("id", (i) => `${this.patternId}-${i}`).attr("patternUnits", "userSpaceOnUse").attr("width", (i) => spacings(i)).attr("height", (i) => spacings(i));
+		tiles.selectAll("rect").data((i) => [i]).join("rect").attr("width", (i) => spacings(i)).attr("height", (i) => spacings(i)).attr("fill", ctx.theme.surface);
+		tiles.selectAll("path").data((i) => [i]).join("path").attr("d", (i) => this.tile(spacings(i))).attr("fill", "none").attr("stroke", ctx.theme.inkSecondary).attr("stroke-width", this.options.hatch === "stipple" ? 1.8 : .9).attr("stroke-linecap", "round");
+	}
+	classes() {
+		return new GeoClasses(this.known(this.regions()).map((region) => region.value), this.options.classification, this.options.bins);
+	}
+	drawMap(ctx, frame) {
+		const classes = this.classes(), { theme } = ctx;
+		this.drawPatterns(ctx, classes);
+		const shapes = ctx.marks("regions", "path", this.regions(), (d) => d.key).attr("fill", (d) => d.value === null ? theme.grid : `url(#${this.patternId}-${classes.bin(d.value)})`).attr("stroke", theme.inkMuted).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"]]
+		}));
+	}
+	drawKey(ctx, frame) {
+		const classes = this.classes(), width = Math.min(190, ctx.plot.width * .6), y = frame.height + 8;
+		const x = scaleLinear([classes.min, classes.max], [0, width]);
+		ctx.marks("key-swatches", "rect", range(classes.bins)).attr("x", (i) => x(classes.breaks[i])).attr("y", y).attr("height", 10).attr("width", (i) => Math.max(1, x(classes.breaks[i + 1]) - x(classes.breaks[i]) - 2)).attr("fill", (i) => `url(#${this.patternId}-${i})`).attr("stroke", ctx.theme.inkMuted).attr("stroke-width", .5);
+		ctx.text(ctx.marks("key-ticks", "text", [classes.min, classes.max]).attr("x", (d) => x(d)).attr("y", y + 21).attr("text-anchor", (_, i) => i ? "end" : "start").text((d) => Scales.format(d, classes.max)), 10, "muted");
+	}
+};
+export { GeoHatch, HatchedChoropleth };