@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/geomaps/ThiessenMap.js

@@ -0,0 +1,106 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { GeoClasses } from "./GeoClasses.js";
+import { GeoLegend } from "./GeoLegend.js";
+import { GeoProjectionKind } from "./GeoProjection.js";
+import { GeoSamples } from "./GeoSamples.js";
+import { PointMap } from "./PointMap.js";
+import { Delaunay, extent, scaleLinear } from "d3";
+// src/charts/geomaps/ThiessenMap.ts
+var GeoTessellation = /* @__PURE__ */ function(GeoTessellation) {
+	GeoTessellation["Voronoi"] = "voronoi";
+	GeoTessellation["Delaunay"] = "delaunay";
+	GeoTessellation["Both"] = "both";
+	return GeoTessellation;
+}({});
+/** Thiessen polygons: every location belongs to its nearest site, for service areas and station catchments. */
+var ThiessenMap = class extends PointMap {
+	static meta = {
+		id: "thiessen-map",
+		name: "Thiessen map",
+		family: ChartFamily.Geospatial,
+		dimension: Dimension.Two,
+		shape: DataShape.Geo,
+		description: "Divides the map into nearest-site Voronoi cells, or its Delaunay mesh, for catchments and proximity.",
+		tags: [
+			"map",
+			"voronoi",
+			"delaunay",
+			"proximity",
+			"catchment"
+		],
+		sample: (seed) => GeoSamples.scatter(seed, 70),
+		variants: {
+			tessellation: [
+				"voronoi",
+				"delaunay",
+				"both"
+			],
+			stations: [true, false],
+			coast: [true, false],
+			projection: [
+				GeoProjectionKind.NaturalEarth,
+				GeoProjectionKind.EqualEarth,
+				GeoProjectionKind.Mollweide,
+				GeoProjectionKind.Orthographic
+			]
+		},
+		valid: (values) => values.tessellation !== "delaunay" || values.coast === true
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			tessellation: "voronoi",
+			stations: true,
+			coast: true,
+			graticule: false
+		};
+	}
+	keyHeight() {
+		return GeoLegend.height;
+	}
+	drawKey(ctx, frame) {
+		const classes = new GeoClasses(this.sites(frame).map((site) => site.value));
+		GeoLegend.classes(ctx, frame, classes, (value) => ctx.palette.sequential(.05 + .8 * classes.tone(value)));
+	}
+	drawMap(ctx, frame) {
+		const { tessellation, stations, coast, value } = this.options, { theme, palette } = ctx;
+		const sites = this.sites(frame);
+		const seen = /* @__PURE__ */ new Set();
+		const unique = sites.filter((d) => {
+			const key = `${d.x.toFixed(2)},${d.y.toFixed(2)}`;
+			return seen.has(key) ? false : !!seen.add(key);
+		});
+		const delaunay = Delaunay.from(unique, (d) => d.x, (d) => d.y);
+		const voronoi = delaunay.voronoi([
+			0,
+			0,
+			frame.width,
+			frame.height
+		]);
+		const layer = ctx.group("cells-layer").attr("clip-path", this.clip(ctx, frame.path({ type: "Sphere" }) ?? ""));
+		const [low = 0, high = 1] = extent(unique, (d) => d.value);
+		const tone = scaleLinear([low, high > low ? high : low + 1], [.05, .85]);
+		const cellsOn = tessellation !== "delaunay";
+		const cells = ctx.marks("cells", "path", cellsOn ? unique : [], (d) => d.key, layer).attr("fill", (d) => palette.sequential(tone(d.value))).attr("stroke", theme.surface).attr("stroke-width", 1);
+		ctx.set(cells, {
+			d: (_, i) => voronoi.renderCell(i),
+			"fill-opacity": 1
+		}, {
+			d: (_, i) => voronoi.renderCell(i),
+			"fill-opacity": 0
+		});
+		ctx.hover(cells, (d) => ({
+			title: d.name,
+			rows: [[value, d.value]]
+		}));
+		const mesh = tessellation === "voronoi" || unique.length < 3 ? [] : [delaunay.render()];
+		ctx.marks("mesh", "path", mesh, void 0, layer).attr("d", (d) => d).attr("fill", "none").attr("stroke", tessellation === "both" ? theme.surface : theme.inkMuted).attr("stroke-width", 1);
+		ctx.marks("coast", "path", coast || tessellation === "delaunay" ? [this.land] : []).attr("d", (d) => frame.path(d) ?? "").attr("fill", tessellation === "delaunay" ? theme.grid : "none").attr("stroke", theme.inkSecondary).attr("stroke-width", this.hairline(ctx)).attr("pointer-events", "none").lower();
+		const dots = ctx.marks("stations", "circle", stations ? unique : [], (d) => d.key).attr("cx", (d) => d.x).attr("cy", (d) => d.y).attr("r", 2.5).attr("fill", theme.ink).attr("stroke", theme.surface).attr("stroke-width", 1);
+		ctx.hover(dots, (d) => ({
+			title: d.name,
+			rows: [[value, d.value]]
+		}));
+	}
+};
+export { GeoTessellation, ThiessenMap };

package/dist/charts/geomaps/TileGridMap.js

@@ -0,0 +1,93 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { GeoProjectionKind } from "./GeoProjection.js";
+import { GeoSamples } from "./GeoSamples.js";
+import { TileMap } from "./TileMap.js";
+import { max, range } from "d3";
+// src/charts/geomaps/TileGridMap.ts
+var GeoTileShape = /* @__PURE__ */ function(GeoTileShape) {
+	GeoTileShape["Square"] = "square";
+	GeoTileShape["Circle"] = "circle";
+	return GeoTileShape;
+}({});
+/** Tone keeps tiles full and shades them; Area shrinks each tile so its size carries the value too. */
+var GeoTileEncoding = /* @__PURE__ */ function(GeoTileEncoding) {
+	GeoTileEncoding["Tone"] = "tone";
+	GeoTileEncoding["Area"] = "area";
+	return GeoTileEncoding;
+}({});
+/** Square tile-grid map: the familiar one-tile-per-state layout, tidy enough to hold labels or small marks. */
+var TileGridMap = class extends TileMap {
+	static meta = {
+		id: "tile-grid-map",
+		name: "Tile grid map",
+		family: ChartFamily.Geospatial,
+		dimension: Dimension.Two,
+		shape: DataShape.Geo,
+		description: "Arranges one equal tile per region on a square grid that keeps rough geography and removes area bias.",
+		tags: [
+			"map",
+			"tile",
+			"grid",
+			"square",
+			"cartogram"
+		],
+		sample: (seed) => GeoSamples.inhabited(seed),
+		variants: {
+			tile: ["square", "circle"],
+			encoding: ["tone", "area"],
+			coverage: [
+				.42,
+				.3,
+				.6
+			],
+			projection: [
+				GeoProjectionKind.EqualEarth,
+				GeoProjectionKind.NaturalEarth,
+				GeoProjectionKind.Mollweide,
+				GeoProjectionKind.Miller
+			]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			tile: "square",
+			encoding: "tone"
+		};
+	}
+	sizeFor(area) {
+		return Math.sqrt(area);
+	}
+	lattice(size, { width, height }) {
+		const columns = Math.floor(width / size), rows = Math.floor(height / size);
+		const left = (width - columns * size) / 2, top = (height - rows * size) / 2;
+		return range(rows).flatMap((row) => range(columns).map((column) => [left + (column + .5) * size, top + (row + .5) * size]));
+	}
+	drawMap(ctx, frame) {
+		const tiles = this.tiles(frame), tone = this.tone(ctx, tiles), cell = tiles[0]?.size ?? 0;
+		const area = this.options.encoding === "area";
+		const top = max(tiles, (d) => Math.abs(d.value ?? 0)) || 1;
+		const side = (d) => Math.max(1, (cell - 2) * (area ? Math.sqrt(Math.abs(d.value ?? 0) / top) : 1));
+		const rounded = (d) => this.options.tile === "circle" ? side(d) / 2 : Math.min(3, side(d) / 4);
+		const marks = ctx.marks("tiles", "rect", tiles, (d) => d.key).attr("fill", tone);
+		ctx.set(marks, {
+			x: (d) => d.x - side(d) / 2,
+			y: (d) => d.y - side(d) / 2,
+			width: side,
+			height: side,
+			rx: rounded
+		}, {
+			x: (d) => d.x,
+			y: (d) => d.y,
+			width: 0,
+			height: 0
+		}, 2);
+		ctx.hover(marks, (d) => ({
+			title: d.name,
+			color: tone(d),
+			rows: [[this.options.value, d.value ?? "No data"]]
+		}));
+		if (!area) this.drawCodes(ctx, tiles, tone, cell);
+	}
+};
+export { GeoTileEncoding, GeoTileShape, TileGridMap };

package/dist/charts/geomaps/TileMap.js

@@ -0,0 +1,75 @@
+import { GeoClasses } from "./GeoClasses.js";
+import { GeoLegend } from "./GeoLegend.js";
+import { GeoProjectionKind } from "./GeoProjection.js";
+import { RegionMap } from "./RegionMap.js";
+import { descending, max } from "d3";
+// src/charts/geomaps/TileMap.ts
+/** Grid maps: every region gets one equal tile, as near its true location as the lattice allows. */
+var TileMap = class extends RegionMap {
+	defaults() {
+		return {
+			...super.defaults(),
+			coverage: .42,
+			labels: true,
+			graticule: false,
+			projection: GeoProjectionKind.EqualEarth
+		};
+	}
+	get framed() {
+		return false;
+	}
+	/** Largest regions choose first, so they land closest to home; the rest take the nearest free tile. */
+	tiles(frame) {
+		const regions = this.regions().flatMap((region) => {
+			const at = frame.anchor(region.feature);
+			return at ? [{
+				region,
+				at,
+				area: frame.path.area(region.feature)
+			}] : [];
+		}).sort((a, b) => descending(a.area, b.area));
+		if (!regions.length) return [];
+		const size = this.sizeFor(frame.width * frame.height * this.options.coverage / regions.length);
+		const free = this.lattice(size, frame);
+		return regions.flatMap(({ region, at: [x, y] }) => {
+			let best = -1, reach = Infinity;
+			free.forEach(([u, v], i) => {
+				const d = (u - x) ** 2 + (v - y) ** 2;
+				if (d < reach) {
+					reach = d;
+					best = i;
+				}
+			});
+			if (best < 0) return [];
+			const [cell] = free.splice(best, 1);
+			return [{
+				...region,
+				x: cell[0],
+				y: cell[1],
+				size
+			}];
+		});
+	}
+	code(tile) {
+		const code = this.options.code ? tile.row[this.options.code] : void 0;
+		return String(code ?? tile.name.replace(/[^\p{L}]/gu, "").slice(0, 3)).toUpperCase();
+	}
+	/** Short codes centred on tiles, only when the tile can hold them. */
+	drawCodes(ctx, tiles, fill, room) {
+		const shown = this.options.labels && room >= 18 ? tiles : [];
+		ctx.text(ctx.marks("codes", "text", shown, (d) => d.key).attr("x", (d) => d.x).attr("y", (d) => d.y + 3).attr("text-anchor", "middle").attr("pointer-events", "none").text((d) => this.code(d)), 8).attr("fill", (d) => this.inkOn(ctx, fill(d)));
+	}
+	keyHeight() {
+		return GeoLegend.height;
+	}
+	drawKey(ctx, frame) {
+		const classes = new GeoClasses(this.known(this.regions()).map((region) => region.value));
+		GeoLegend.classes(ctx, frame, classes, (value) => ctx.palette.sequential(classes.tone(value)));
+	}
+	tone(ctx, tiles) {
+		const known = tiles.map((tile) => tile.value).filter((value) => value !== null);
+		const low = Math.min(...known), top = max(known) ?? 1;
+		return (tile) => tile.value === null ? ctx.theme.grid : ctx.palette.sequential((tile.value - low) / (top - low || 1));
+	}
+};
+export { TileMap };

package/dist/charts/geomaps/TissotMap.js

@@ -0,0 +1,90 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { GeoClasses } from "./GeoClasses.js";
+import { GeoLegend } from "./GeoLegend.js";
+import { GeoProjectionKind } from "./GeoProjection.js";
+import { RegionMap } from "./RegionMap.js";
+import { geoCircle, geoDistance, geoEquirectangular, geoPath, range } from "d3";
+// src/charts/geomaps/TissotMap.ts
+var REACH = 3;
+/** Tissot's indicatrix: identical circles on the sphere, revealing exactly where and how a projection distorts. */
+var TissotMap = class extends RegionMap {
+	static meta = {
+		id: "tissot-map",
+		name: "Tissot indicatrix",
+		family: ChartFamily.Geospatial,
+		dimension: Dimension.Two,
+		shape: DataShape.Geo,
+		description: "Projects equal circles across the globe, shaded by area stretch against the map centre, to expose distortion.",
+		tags: [
+			"map",
+			"projection",
+			"distortion",
+			"indicatrix",
+			"cartography"
+		],
+		sample: (seed) => SampleData.world(seed),
+		variants: {
+			projection: [
+				GeoProjectionKind.Mercator,
+				GeoProjectionKind.NaturalEarth,
+				GeoProjectionKind.Robinson,
+				GeoProjectionKind.EqualEarth,
+				GeoProjectionKind.Mollweide,
+				GeoProjectionKind.WinkelTripel,
+				GeoProjectionKind.Equirectangular,
+				GeoProjectionKind.Orthographic,
+				GeoProjectionKind.AzimuthalEquidistant,
+				GeoProjectionKind.Stereographic,
+				GeoProjectionKind.Sinusoidal,
+				GeoProjectionKind.Hammer
+			],
+			spacing: [30, 20],
+			graticule: [false, true]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			spacing: 30,
+			size: 7,
+			projection: GeoProjectionKind.Mercator,
+			graticule: false
+		};
+	}
+	keyHeight() {
+		return GeoLegend.height;
+	}
+	target() {
+		return null;
+	}
+	drawMap(ctx, frame) {
+		const { spacing, size } = this.options, { theme, palette } = ctx;
+		ctx.marks("land", "path", this.regions(), (d) => d.key).attr("d", (d) => frame.path(d.feature) ?? "").attr("fill", theme.axis).attr("fill-opacity", .5).attr("stroke", theme.surface).attr("stroke-width", this.hairline(ctx));
+		const flat = geoPath(geoEquirectangular().scale(1).translate([0, 0]));
+		const circle = geoCircle();
+		const rings = range(-90 + spacing, 90, spacing).flatMap((lat) => range(-180 + spacing / 2, 180, spacing).map((lon) => {
+			const shape = circle.center([lon, lat]).radius(size)();
+			const area = frame.path.area(shape), truth = flat.area(shape) * Math.cos(lat * Math.PI / 180);
+			return {
+				key: `${lon},${lat}`,
+				lon,
+				lat,
+				shape,
+				stretch: area / truth
+			};
+		})).filter((d) => d.stretch > 0 && Number.isFinite(d.stretch));
+		const middle = frame.projection.invert?.([frame.width / 2, frame.height / 2]) ?? [0, 0];
+		const centre = rings.reduce((best, d) => geoDistance([d.lon, d.lat], middle) < geoDistance([best.lon, best.lat], middle) ? d : best, rings[0]);
+		const ratios = rings.map((d) => d.stretch / (centre?.stretch ?? 1));
+		const tint = (log) => palette.diverging(log / REACH);
+		const marks = ctx.marks("circles", "path", rings, (d) => d.key).attr("fill", (_, i) => tint(Math.log2(ratios[i]))).attr("stroke", theme.inkSecondary).attr("stroke-width", .5);
+		this.fill(ctx, marks, (d) => frame.path(d.shape) ?? "", .82, 2);
+		ctx.hover(marks, (d, i) => ({
+			title: `${d.lat}°, ${d.lon}°`,
+			rows: [["Area stretch", `${ratios[i].toFixed(2)}×`]]
+		}));
+		GeoLegend.classes(ctx, frame, new GeoClasses([-3, REACH]), tint, (log) => `${2 ** log}×`);
+	}
+};
+export { TissotMap };

package/dist/charts/geomaps/UsCountyMap.js

@@ -0,0 +1,59 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { GeoAtlas, GeoLayer } from "../../data/GeoAtlas.js";
+import { GeoClassification } from "./GeoClasses.js";
+import { GeoProjectionKind } from "./GeoProjection.js";
+import { GeoSamples } from "./GeoSamples.js";
+import { UsCoverage, UsMapBase } from "./UsMapBase.js";
+// src/charts/geomaps/UsCountyMap.ts
+/** Show local variation across roughly 3,200 counties. Pass `rows` with a five-digit `fips` column. The shapes load on first use. */
+var UsCountyMap = class extends UsMapBase {
+	static meta = {
+		id: "us-county-map",
+		name: "US county map",
+		family: ChartFamily.Geospatial,
+		dimension: Dimension.Two,
+		shape: DataShape.Geo,
+		description: "Shades every US county, under state lines, to reveal the local pattern a state map averages away.",
+		tags: [
+			"map",
+			"usa",
+			"united states",
+			"county",
+			"counties",
+			"fips",
+			"choropleth"
+		],
+		sample: (seed) => GeoSamples.usStates(seed),
+		prepare: () => GeoAtlas.load(GeoLayer.UsCounties),
+		variants: {
+			projection: [GeoProjectionKind.AlbersUsa, GeoProjectionKind.Albers],
+			coverage: [UsCoverage.All, UsCoverage.Contiguous],
+			classification: [
+				GeoClassification.Continuous,
+				GeoClassification.Quantile,
+				GeoClassification.NaturalBreaks
+			],
+			stateLines: [true, false]
+		},
+		valid: (values) => values.projection === GeoProjectionKind.AlbersUsa || values.coverage === UsCoverage.Contiguous
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			geography: GeoLayer.UsCounties,
+			stateLines: true
+		};
+	}
+	get placeholder() {
+		return true;
+	}
+	adopt(layer, given) {
+		return given?.demo ? GeoSamples.shaded(layer, 1) : layer;
+	}
+	finishRegions(ctx, frame, shapes) {
+		const lines = this.options.stateLines && shapes.size() > 100 ? [GeoAtlas.stateBorders] : [];
+		ctx.marks("state-lines", "path", lines).attr("d", (d) => frame.path(d) ?? "").attr("fill", "none").attr("stroke", ctx.theme.surface).attr("stroke-width", 1).attr("stroke-linejoin", "round").attr("pointer-events", "none");
+		shapes.attr("stroke-width", .15);
+	}
+};
+export { UsCountyMap };

package/dist/charts/geomaps/UsMapBase.js

@@ -0,0 +1,43 @@
+import { ChoroplethBase } from "./ChoroplethBase.js";
+import { GeoProjectionKind } from "./GeoProjection.js";
+// src/charts/geomaps/UsMapBase.ts
+/** How much of the United States a map shows. */
+var UsCoverage = /* @__PURE__ */ function(UsCoverage) {
+	UsCoverage["All"] = "all";
+	UsCoverage["Contiguous"] = "contiguous";
+	return UsCoverage;
+}({});
+var OUTLYING = /* @__PURE__ */ new Set([
+	"AK",
+	"HI",
+	"AS",
+	"GU",
+	"MP",
+	"PR",
+	"VI"
+]);
+/** Choropleths of US states or counties, keyed by FIPS code. */
+var UsMapBase = class extends ChoroplethBase {
+	defaults() {
+		return {
+			...super.defaults(),
+			projection: GeoProjectionKind.AlbersUsa,
+			coverage: "all",
+			graticule: false,
+			join: "fips"
+		};
+	}
+	get framed() {
+		return false;
+	}
+	get features() {
+		const all = super.features;
+		return this.options.coverage === "contiguous" ? all.filter((feature) => !OUTLYING.has(feature.properties?.code)) : all;
+	}
+	/** Whether a region is big enough on this map to hold a label. */
+	roomy(frame, feature, text, ctx) {
+		const [[x0, y0], [x1, y1]] = frame.path.bounds(feature);
+		return ctx.plot.width > 280 && x1 - x0 > text.length * 7 + 4 && y1 - y0 > 13;
+	}
+};
+export { UsCoverage, UsMapBase };

package/dist/charts/geomaps/UsStateMap.js

@@ -0,0 +1,68 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { GeoClassification } from "./GeoClasses.js";
+import { GeoProjectionKind } from "./GeoProjection.js";
+import { GeoSamples } from "./GeoSamples.js";
+import { UsCoverage, UsMapBase } from "./UsMapBase.js";
+// src/charts/geomaps/UsStateMap.ts
+/** Compare the 50 states and DC. Features carry `fips`, `code` and `name`, so `rows` can join on any of them. */
+var UsStateMap = class extends UsMapBase {
+	static meta = {
+		id: "us-state-map",
+		name: "US state map",
+		family: ChartFamily.Geospatial,
+		dimension: Dimension.Two,
+		shape: DataShape.Geo,
+		description: "Shades the 50 states and DC, with Alaska and Hawaii inset, to compare a rate across the country.",
+		tags: [
+			"map",
+			"usa",
+			"united states",
+			"states",
+			"choropleth",
+			"albers"
+		],
+		sample: (seed) => GeoSamples.usStates(seed),
+		variants: {
+			projection: [
+				GeoProjectionKind.AlbersUsa,
+				GeoProjectionKind.Albers,
+				GeoProjectionKind.Mercator,
+				GeoProjectionKind.ConicEquidistant,
+				GeoProjectionKind.Equirectangular
+			],
+			coverage: [UsCoverage.All, UsCoverage.Contiguous],
+			classification: [
+				GeoClassification.Continuous,
+				GeoClassification.Quantile,
+				GeoClassification.EqualInterval,
+				GeoClassification.NaturalBreaks
+			],
+			bins: [
+				5,
+				3,
+				7
+			],
+			labels: [true, false]
+		},
+		valid: (values) => (values.classification !== GeoClassification.Continuous || values.bins === 5) && (values.projection === GeoProjectionKind.AlbersUsa || values.coverage === UsCoverage.Contiguous)
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			labels: true,
+			name: "name"
+		};
+	}
+	finishRegions(ctx, frame, shapes) {
+		const labelled = this.options.labels ? shapes.data().flatMap((region) => {
+			const code = String(region.row.code ?? ""), at = code ? frame.anchor(region.feature) : null;
+			return at && this.roomy(frame, region.feature, code, ctx) ? [{
+				code,
+				at,
+				fill: shapes.filter((d) => d === region).attr("fill")
+			}] : [];
+		}) : [];
+		ctx.text(ctx.marks("codes", "text", labelled, (d) => d.code), 10, "ink").attr("x", (d) => d.at[0]).attr("y", (d) => d.at[1] + 3.5).attr("text-anchor", "middle").attr("pointer-events", "none").attr("fill", (d) => this.inkOn(ctx, d.fill)).text((d) => d.code);
+	}
+};
+export { UsStateMap };

package/dist/charts/geomaps/index.js

@@ -0,0 +1,74 @@
+import { GeoClasses, GeoClassification } from "./GeoClasses.js";
+import { GeoFraming, GeoProjectionKind, GeoProjections } from "./GeoProjection.js";
+import { GeoLand } from "./GeoLand.js";
+import { GeoViewport } from "./GeoViewport.js";
+import { GeoChart } from "./GeoChart.js";
+import { RegionMap } from "./RegionMap.js";
+import { BivariateChoropleth, GeoBivariateKey } from "./BivariateChoropleth.js";
+import { GeoLegend } from "./GeoLegend.js";
+import { GeoGround, PointMap } from "./PointMap.js";
+import { BubbleMap, GeoBubblePlacement } from "./BubbleMap.js";
+import { CartogramDorling, GeoCartogramMark } from "./CartogramDorling.js";
+import { ChoroplethBase } from "./ChoroplethBase.js";
+import { ChoroplethMap } from "./ChoroplethMap.js";
+import { ClippedGlobeMap, GeoView } from "./ClippedGlobeMap.js";
+import { GeoField, GeoInterpolation, GeoKernel } from "./GeoField.js";
+import { ContourMap, GeoContourStyle } from "./ContourMap.js";
+import { DotDensityMap, GeoDotPattern } from "./DotDensityMap.js";
+import { DrillDownMap } from "./DrillDownMap.js";
+import { DotMap } from "./DotMap.js";
+import { GraticuleMap } from "./GraticuleMap.js";
+import { GeoHatch, HatchedChoropleth } from "./HatchedChoropleth.js";
+import { HeatMapGeo } from "./HeatMapGeo.js";
+import { TileMap } from "./TileMap.js";
+import { GeoHexOrientation, HexTileMap } from "./HexTileMap.js";
+import { GeoCorner, GeoFocus, GeoLocator, InsetMap } from "./InsetMap.js";
+import { GeoLabelPlacement, GeoLabelSubject, LabelledMap } from "./LabelledMap.js";
+import { NonContiguousCartogram } from "./NonContiguousCartogram.js";
+import { GeoGlyph, GeoGlyphSize, PieChartMap } from "./PieChartMap.js";
+import { GeoBinEncoding, GeoBinning, PointDensityMap } from "./PointDensityMap.js";
+import { GeoPrismView, PrismLikeShadedMap } from "./PrismLikeShadedMap.js";
+import { GeoSizing, ProportionalSymbolMap } from "./ProportionalSymbolMap.js";
+import { RidgelineMap } from "./RidgelineMap.js";
+import { OPEN_STREET_MAP, SlippyView } from "./SlippyView.js";
+import { SlippyMarker, SlippyPointMap } from "./SlippyPointMap.js";
+import { SlippyRegionMap } from "./SlippyRegionMap.js";
+import { GeoSpikeLean, GeoSpikeShape, SpikeMap } from "./SpikeMap.js";
+import { GeoTessellation, ThiessenMap } from "./ThiessenMap.js";
+import { GeoTileEncoding, GeoTileShape, TileGridMap } from "./TileGridMap.js";
+import { TissotMap } from "./TissotMap.js";
+import { UsCountyMap } from "./UsCountyMap.js";
+import { UsStateMap } from "./UsStateMap.js";
+// src/charts/geomaps/index.ts
+var geomapsCatalog = [
+	ChoroplethMap,
+	HatchedChoropleth,
+	BivariateChoropleth,
+	ProportionalSymbolMap,
+	BubbleMap,
+	DotMap,
+	DotDensityMap,
+	SpikeMap,
+	PieChartMap,
+	PointDensityMap,
+	HeatMapGeo,
+	ContourMap,
+	RidgelineMap,
+	ThiessenMap,
+	CartogramDorling,
+	NonContiguousCartogram,
+	HexTileMap,
+	TileGridMap,
+	PrismLikeShadedMap,
+	ClippedGlobeMap,
+	LabelledMap,
+	InsetMap,
+	GraticuleMap,
+	TissotMap,
+	UsStateMap,
+	UsCountyMap,
+	DrillDownMap,
+	SlippyPointMap,
+	SlippyRegionMap
+];
+export { BivariateChoropleth, BubbleMap, CartogramDorling, ChoroplethBase, ChoroplethMap, ClippedGlobeMap, ContourMap, DotDensityMap, DotMap, DrillDownMap, GeoBinEncoding, GeoBinning, GeoBivariateKey, GeoBubblePlacement, GeoCartogramMark, GeoChart, GeoClasses, GeoClassification, GeoContourStyle, GeoCorner, GeoDotPattern, GeoField, GeoFocus, GeoFraming, GeoGlyph, GeoGlyphSize, GeoGround, GeoHatch, GeoHexOrientation, GeoInterpolation, GeoKernel, GeoLabelPlacement, GeoLabelSubject, GeoLand, GeoLegend, GeoLocator, GeoPrismView, GeoProjectionKind, GeoProjections, GeoSizing, GeoSpikeLean, GeoSpikeShape, GeoTessellation, GeoTileEncoding, GeoTileShape, GeoView, GeoViewport, GraticuleMap, HatchedChoropleth, HeatMapGeo, HexTileMap, InsetMap, LabelledMap, NonContiguousCartogram, OPEN_STREET_MAP, PieChartMap, PointDensityMap, PointMap, PrismLikeShadedMap, ProportionalSymbolMap, RegionMap, RidgelineMap, SlippyMarker, SlippyPointMap, SlippyRegionMap, SlippyView, SpikeMap, ThiessenMap, TileGridMap, TileMap, TissotMap, UsCountyMap, UsStateMap, geomapsCatalog };