@motionscript/geography 0.1.0-alpha.7 → 0.1.0-alpha.8

package/dist/border/geo-border.js

@@ -0,0 +1,203 @@
+import { Flow, Graphics2D, Paint, Shapes, Types, component2d, } from "@motionscript/sdk";
+import { snapValue } from "@motionscript/sdk/component";
+import { geoGeometry } from "./geometry.js";
+import { geoDataVersion, geoLoader } from "./loader.js";
+import { geoRegistry } from "./registry.js";
+import { geoFilesFor, normalizeIso, selectGeoFeatures } from "./selection.js";
+// A renderer's cost for one path grows faster than its contour count, and a shape
+// drawn as several paths under one paint is unioned every frame — so a region
+// is cut into paths of bounded size, each painted on its own.
+const CONTOURS_PER_PATH = 256;
+const POINTS_PER_PATH = 40_000;
+const coordinate = (value) => String(Math.round(value * 100) / 100);
+function chunk(contours, total, scale) {
+    const chunks = [];
+    let parts = [];
+    let count = 0;
+    let points = 0;
+    let from = 0;
+    let length = 0;
+    const flush = () => {
+        if (count === 0)
+            return;
+        const to = total > 0 ? Math.min(1, length / total) : 1;
+        chunks.push({ data: parts.join(""), from, to });
+        from = to;
+        parts = [];
+        count = 0;
+        points = 0;
+    };
+    for (const contour of contours) {
+        const p = contour.points;
+        // Path data is y-down; the unit geometry is y-up.
+        for (let i = 0; i < p.length; i += 2) {
+            parts.push(i === 0 ? "M" : "L", coordinate(p[i] * scale), " ", coordinate(-p[i + 1] * scale));
+        }
+        if (contour.closed)
+            parts.push("Z");
+        count++;
+        points += p.length / 2;
+        length += contour.length;
+        if (count >= CONTOURS_PER_PATH || points >= POINTS_PER_PATH)
+            flush();
+    }
+    flush();
+    return chunks;
+}
+/** One of `values`, switched at the end of a `to`, with its choices listed as its `options`. */
+function choice(values, initial) {
+    return Types.custom(initial, { lerp: snapValue, options: values });
+}
+const kept = new WeakMap();
+function keptBy(state) {
+    let entry = kept.get(state);
+    if (!entry)
+        kept.set(state, (entry = { drawn: null, warned: new Set() }));
+    return entry;
+}
+/** The selection's outlines cut into paths at `size`, or `null` while there is nothing to draw. */
+function drawnOf(state, size) {
+    const own = keptBy(state);
+    const codes = state.iso;
+    const { level, frame } = state;
+    const selection = selectGeoFeatures(codes, level, frame);
+    for (const code of selection.unknown) {
+        if (own.warned.has(code))
+            continue;
+        own.warned.add(code);
+        console.warn(`[GeoBorder] no region with code ${code}`);
+    }
+    if (selection.features.length === 0)
+        return null;
+    const geometry = geoGeometry({
+        selectionKey: `${geoRegistry.generation}:${geoDataVersion()}:${level}:${frame}:${codes.join(",")}`,
+        features: selection.features,
+        frame,
+        projection: state.projection,
+        borders: state.borders,
+        detail: state.detail,
+    });
+    if (!geometry)
+        return null;
+    const { width, height } = size;
+    const cached = own.drawn;
+    if (cached && cached.geometry === geometry && cached.width === width && cached.height === height)
+        return cached;
+    const scale = Math.min(width / geometry.width, height / geometry.height);
+    const drawn = {
+        geometry,
+        width,
+        height,
+        fills: chunk(geometry.fills, geometry.fillLength, scale),
+        lines: chunk(geometry.lines, geometry.lineLength, scale),
+    };
+    own.drawn = drawn;
+    return drawn;
+}
+/** Adds `chunk` to `g`, trimmed by `start`/`end` along the whole drawing; `false` when none of it is drawn. */
+function pathOp(g, chunk, size, start, end) {
+    const { width, height } = size;
+    const centerBounds = [-width / 2, -height / 2, width / 2, height / 2];
+    if (start <= 0 && end >= 1) {
+        g.path({ data: chunk.data, centerBounds });
+        return true;
+    }
+    const span = chunk.to - chunk.from;
+    if (span <= 0)
+        return false;
+    const localStart = Math.max(0, (start - chunk.from) / span);
+    const localEnd = Math.min(1, (end - chunk.from) / span);
+    if (localEnd <= localStart)
+        return false;
+    g.path({ data: chunk.data, centerBounds, start: localStart, end: localEnd });
+    return true;
+}
+/**
+ * Country and subdivision outlines by ISO 3166 code, fitted into the node's box.
+ *
+ *   <GeoBorder iso={["FR", "DE"]} detail={0.4} stroke={{ weight: 2, fill: "white" }} />
+ *
+ * Geometry comes from whatever `geoRegistry` has been given — a URL, a loader,
+ * or shapes defined by hand — and loads as a declared asset, so a frame never
+ * draws half a country. Fill and stroke are separate geometry: the fill is each
+ * region's polygons, the stroke is every border once, which is why a border two
+ * selected regions share is not drawn twice and why `stroke.align` does not
+ * apply.
+ */
+export const GeoBorder = component2d({
+    key: "geoBorder",
+    state: {
+        ...Paint.state,
+        ...Flow.state,
+        iso: Types.custom(["FR"], { resolve: normalizeIso, lerp: snapValue }),
+        level: choice(["country", "state"], "country"),
+        detail: Types.number(0.5, { min: 0, max: 1, step: 0.01 }),
+        projection: choice(["conic", "mercator", "equirectangular", "orthographic"], "conic"),
+        frame: choice(["mainland", "all"], "mainland"),
+        borders: choice(["all", "outline"], "all"),
+    },
+    commands: { ...Paint.commands },
+    // The data gates the draw, not layout: the box never waits on it.
+    load: (loader, state) => {
+        for (const file of geoFilesFor(state.iso, state.level))
+            loader.task(`geo:${file}`, geoLoader(file));
+    },
+    measure: (measurer, state, children) => Flow.measure(measurer, state, children, Paint.inset(state)),
+    layout: (box, state, children) => Flow.layout(box, state, children, Paint.inset(state)),
+    render: (ctx, state) => {
+        const size = ctx.size;
+        const { start, end } = state;
+        const fill = state.fill;
+        const shadow = state.shadow;
+        const drawn = () => drawnOf(state, size);
+        ctx.inFront(() => {
+            const shape = drawn();
+            if (!shape || shape.fills.length === 0)
+                return;
+            const g = new Graphics2D();
+            for (const part of shape.fills) {
+                if (!pathOp(g, part, size, start, end))
+                    continue;
+                if (shadow.length > 0)
+                    g.shadow(shadow);
+                g.fill(fill);
+            }
+            ctx.draw(g);
+        });
+        // The box, not the outline, confines the children and is what picking
+        // tests: a path clip has no winding test, and a country's bounding box is
+        // what the selection shows.
+        Paint.draw(ctx, state, null, { clipShape: Shapes.box(size) });
+        ctx.inFront(() => {
+            const overlay = state.overlay;
+            if (overlay.length > 0) {
+                const shape = drawn();
+                if (shape) {
+                    const g = new Graphics2D();
+                    for (const part of shape.fills)
+                        if (pathOp(g, part, size, start, end))
+                            g.fill(overlay);
+                    ctx.draw(g);
+                }
+            }
+            const stroke = state.stroke;
+            if (stroke.length === 0)
+                return;
+            const shape = drawn();
+            if (!shape || shape.lines.length === 0)
+                return;
+            const centred = stroke.map((layer) => (layer.align === 0 ? layer : { ...layer, align: 0 }));
+            const castsShadow = shadow.length > 0 && !fill.some((layer) => (layer.opacity ?? 1) > 0);
+            const g = new Graphics2D();
+            for (const part of shape.lines) {
+                if (!pathOp(g, part, size, start, end))
+                    continue;
+                if (castsShadow)
+                    g.shadow(shadow);
+                g.stroke(centred);
+            }
+            ctx.draw(g);
+        });
+    },
+});
+//# sourceMappingURL=geo-border.js.map

package/dist/border/geo-border.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geo-border.js","sourceRoot":"","sources":["../../src/border/geo-border.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    Flow,\r\n    Graphics2D,\r\n    Paint,\r\n    Shapes,\r\n    Types,\r\n    component2d,\r\n    type EntryOptions,\r\n    type FillResolved,\r\n    type NodeOf,\r\n    // Named so this component's emitted type reaches the shape surface it spreads through the sdk, not core.\r\n    type Alignment as _Alignment,\r\n    type Fill as _Fill,\r\n    type FlowMode as _FlowMode,\r\n    type FlowResolved as _FlowResolved,\r\n    type GapSize as _GapSize,\r\n    type Node2D as _Node2D,\r\n    type Node2DProps as _Node2DProps,\r\n    type Shadow as _Shadow,\r\n    type Stroke as _Stroke,\r\n    type Vector2 as _Vector2,\r\n    type PathBounds,\r\n    type ShadowResolved,\r\n    type ShapeProps,\r\n    type Size2D,\r\n    type StrokeResolved,\r\n    type Type,\r\n} from \"@motionscript/sdk\"\r\nimport { snapValue } from \"@motionscript/sdk/component\"\r\n\r\nimport { geoGeometry, type GeoBorders, type GeoContour, type GeoGeometry, type GeoProjectionKind } from \"./geometry\"\r\nimport { geoDataVersion, geoLoader } from \"./loader\"\r\nimport { geoRegistry } from \"./registry\"\r\nimport { geoFilesFor, normalizeIso, selectGeoFeatures, type GeoFrame, type GeoLevel } from \"./selection\"\r\n\r\nexport interface GeoBorderProps extends ShapeProps {\r\n    /** ISO 3166-1 alpha-2 (`\"FR\"`) or ISO 3166-2 (`\"US-CA\"`) codes. */\r\n    iso: string | readonly string[]\r\n    level: GeoLevel\r\n    /** 0–1: 1 is full resolution, lower is a more stylised outline. */\r\n    detail: number\r\n    projection: GeoProjectionKind\r\n    frame: GeoFrame\r\n    borders: GeoBorders\r\n}\r\n\r\ninterface Chunk {\r\n    data: string\r\n    /** Where this chunk's contours sit along the whole drawing, as fractions of its length. */\r\n    from: number\r\n    to: number\r\n}\r\n\r\ninterface Drawn {\r\n    geometry: GeoGeometry\r\n    width: number\r\n    height: number\r\n    fills: Chunk[]\r\n    lines: Chunk[]\r\n}\r\n\r\n// A renderer's cost for one path grows faster than its contour count, and a shape\r\n// drawn as several paths under one paint is unioned every frame — so a region\r\n// is cut into paths of bounded size, each painted on its own.\r\nconst CONTOURS_PER_PATH = 256\r\nconst POINTS_PER_PATH = 40_000\r\n\r\nconst coordinate = (value: number) => String(Math.round(value * 100) / 100)\r\n\r\nfunction chunk(contours: readonly GeoContour[], total: number, scale: number): Chunk[] {\r\n    const chunks: Chunk[] = []\r\n    let parts: string[] = []\r\n    let count = 0\r\n    let points = 0\r\n    let from = 0\r\n    let length = 0\r\n    const flush = () => {\r\n        if (count === 0) return\r\n        const to = total > 0 ? Math.min(1, length / total) : 1\r\n        chunks.push({ data: parts.join(\"\"), from, to })\r\n        from = to\r\n        parts = []\r\n        count = 0\r\n        points = 0\r\n    }\r\n    for (const contour of contours) {\r\n        const p = contour.points\r\n        // Path data is y-down; the unit geometry is y-up.\r\n        for (let i = 0; i < p.length; i += 2) {\r\n            parts.push(i === 0 ? \"M\" : \"L\", coordinate(p[i] * scale), \" \", coordinate(-p[i + 1] * scale))\r\n        }\r\n        if (contour.closed) parts.push(\"Z\")\r\n        count++\r\n        points += p.length / 2\r\n        length += contour.length\r\n        if (count >= CONTOURS_PER_PATH || points >= POINTS_PER_PATH) flush()\r\n    }\r\n    flush()\r\n    return chunks\r\n}\r\n\r\n/** One of `values`, switched at the end of a `to`, with its choices listed as its `options`. */\r\nfunction choice<const V extends readonly string[]>(values: V, initial: V[number]): Type<V[number]> {\r\n    return Types.custom<V[number], V[number], EntryOptions & { readonly options: V }>(initial, { lerp: snapValue, options: values })\r\n}\r\n\r\n/** A node's own drawing state, kept by its fields' view (one object per node, the same every frame). */\r\ninterface Kept {\r\n    drawn: Drawn | null\r\n    readonly warned: Set<string>\r\n}\r\n\r\nconst kept = new WeakMap<object, Kept>()\r\n\r\nfunction keptBy(state: object): Kept {\r\n    let entry = kept.get(state)\r\n    if (!entry) kept.set(state, (entry = { drawn: null, warned: new Set() }))\r\n    return entry\r\n}\r\n\r\ninterface Selected {\r\n    readonly iso: readonly string[]\r\n    readonly level: GeoLevel\r\n    readonly frame: GeoFrame\r\n    readonly projection: GeoProjectionKind\r\n    readonly borders: GeoBorders\r\n    readonly detail: number\r\n}\r\n\r\n/** The selection's outlines cut into paths at `size`, or `null` while there is nothing to draw. */\r\nfunction drawnOf(state: Selected, size: Size2D): Drawn | null {\r\n    const own = keptBy(state)\r\n    const codes = state.iso\r\n    const { level, frame } = state\r\n    const selection = selectGeoFeatures(codes, level, frame)\r\n    for (const code of selection.unknown) {\r\n        if (own.warned.has(code)) continue\r\n        own.warned.add(code)\r\n        console.warn(`[GeoBorder] no region with code ${code}`)\r\n    }\r\n    if (selection.features.length === 0) return null\r\n\r\n    const geometry = geoGeometry({\r\n        selectionKey: `${geoRegistry.generation}:${geoDataVersion()}:${level}:${frame}:${codes.join(\",\")}`,\r\n        features: selection.features,\r\n        frame,\r\n        projection: state.projection,\r\n        borders: state.borders,\r\n        detail: state.detail,\r\n    })\r\n    if (!geometry) return null\r\n\r\n    const { width, height } = size\r\n    const cached = own.drawn\r\n    if (cached && cached.geometry === geometry && cached.width === width && cached.height === height) return cached\r\n    const scale = Math.min(width / geometry.width, height / geometry.height)\r\n    const drawn: Drawn = {\r\n        geometry,\r\n        width,\r\n        height,\r\n        fills: chunk(geometry.fills, geometry.fillLength, scale),\r\n        lines: chunk(geometry.lines, geometry.lineLength, scale),\r\n    }\r\n    own.drawn = drawn\r\n    return drawn\r\n}\r\n\r\n/** Adds `chunk` to `g`, trimmed by `start`/`end` along the whole drawing; `false` when none of it is drawn. */\r\nfunction pathOp(g: Graphics2D, chunk: Chunk, size: Size2D, start: number, end: number): boolean {\r\n    const { width, height } = size\r\n    const centerBounds: PathBounds = [-width / 2, -height / 2, width / 2, height / 2]\r\n    if (start <= 0 && end >= 1) {\r\n        g.path({ data: chunk.data, centerBounds })\r\n        return true\r\n    }\r\n    const span = chunk.to - chunk.from\r\n    if (span <= 0) return false\r\n    const localStart = Math.max(0, (start - chunk.from) / span)\r\n    const localEnd = Math.min(1, (end - chunk.from) / span)\r\n    if (localEnd <= localStart) return false\r\n    g.path({ data: chunk.data, centerBounds, start: localStart, end: localEnd })\r\n    return true\r\n}\r\n\r\n/**\r\n * Country and subdivision outlines by ISO 3166 code, fitted into the node's box.\r\n *\r\n *   <GeoBorder iso={[\"FR\", \"DE\"]} detail={0.4} stroke={{ weight: 2, fill: \"white\" }} />\r\n *\r\n * Geometry comes from whatever `geoRegistry` has been given — a URL, a loader,\r\n * or shapes defined by hand — and loads as a declared asset, so a frame never\r\n * draws half a country. Fill and stroke are separate geometry: the fill is each\r\n * region's polygons, the stroke is every border once, which is why a border two\r\n * selected regions share is not drawn twice and why `stroke.align` does not\r\n * apply.\r\n */\r\nexport const GeoBorder = component2d({\r\n    key: \"geoBorder\",\r\n    state: {\r\n        ...Paint.state,\r\n        ...Flow.state,\r\n        iso: Types.custom<string | readonly string[], string[]>([\"FR\"], { resolve: normalizeIso, lerp: snapValue }),\r\n        level: choice([\"country\", \"state\"], \"country\"),\r\n        detail: Types.number(0.5, { min: 0, max: 1, step: 0.01 }),\r\n        projection: choice([\"conic\", \"mercator\", \"equirectangular\", \"orthographic\"], \"conic\"),\r\n        frame: choice([\"mainland\", \"all\"], \"mainland\"),\r\n        borders: choice([\"all\", \"outline\"], \"all\"),\r\n    },\r\n    commands: { ...Paint.commands },\r\n    // The data gates the draw, not layout: the box never waits on it.\r\n    load: (loader, state) => {\r\n        for (const file of geoFilesFor(state.iso, state.level)) loader.task(`geo:${file}`, geoLoader(file))\r\n    },\r\n    measure: (measurer, state, children) => Flow.measure(measurer, state, children, Paint.inset(state)),\r\n    layout: (box, state, children) => Flow.layout(box, state, children, Paint.inset(state)),\r\n    render: (ctx, state) => {\r\n        const size = ctx.size\r\n        const { start, end } = state\r\n        const fill = state.fill as FillResolved[]\r\n        const shadow = state.shadow as ShadowResolved[]\r\n        const drawn = () => drawnOf(state, size)\r\n\r\n        ctx.inFront(() => {\r\n            const shape = drawn()\r\n            if (!shape || shape.fills.length === 0) return\r\n            const g = new Graphics2D()\r\n            for (const part of shape.fills) {\r\n                if (!pathOp(g, part, size, start, end)) continue\r\n                if (shadow.length > 0) g.shadow(shadow)\r\n                g.fill(fill)\r\n            }\r\n            ctx.draw(g)\r\n        })\r\n\r\n        // The box, not the outline, confines the children and is what picking\r\n        // tests: a path clip has no winding test, and a country's bounding box is\r\n        // what the selection shows.\r\n        Paint.draw(ctx, state, null, { clipShape: Shapes.box(size) })\r\n\r\n        ctx.inFront(() => {\r\n            const overlay = state.overlay as FillResolved[]\r\n            if (overlay.length > 0) {\r\n                const shape = drawn()\r\n                if (shape) {\r\n                    const g = new Graphics2D()\r\n                    for (const part of shape.fills) if (pathOp(g, part, size, start, end)) g.fill(overlay)\r\n                    ctx.draw(g)\r\n                }\r\n            }\r\n\r\n            const stroke = state.stroke as StrokeResolved[]\r\n            if (stroke.length === 0) return\r\n            const shape = drawn()\r\n            if (!shape || shape.lines.length === 0) return\r\n            const centred = stroke.map((layer) => (layer.align === 0 ? layer : { ...layer, align: 0 }))\r\n            const castsShadow = shadow.length > 0 && !fill.some((layer) => (layer.opacity ?? 1) > 0)\r\n            const g = new Graphics2D()\r\n            for (const part of shape.lines) {\r\n                if (!pathOp(g, part, size, start, end)) continue\r\n                if (castsShadow) g.shadow(shadow)\r\n                g.stroke(centred)\r\n            }\r\n            ctx.draw(g)\r\n        })\r\n    },\r\n})\r\n\r\nexport type GeoBorder = NodeOf<typeof GeoBorder>\r\n"]}

package/dist/border/geometry.d.ts

@@ -0,0 +1,40 @@
+import { type GeoFeature } from "./format.js";
+import type { GeoFrame } from "./selection.js";
+export type GeoProjectionKind = "conic" | "mercator" | "equirectangular" | "orthographic";
+export type GeoBorders = "all" | "outline";
+export interface GeoContour {
+    /** Interleaved x/y in unit space: the longer side spans 1, centred on the origin, y up. */
+    points: Float32Array;
+    closed: boolean;
+    length: number;
+}
+export interface GeoGeometry {
+    /** The drawing's extent in unit space; the longer of the two is 1. */
+    width: number;
+    height: number;
+    fills: GeoContour[];
+    lines: GeoContour[];
+    fillLength: number;
+    lineLength: number;
+    bytes: number;
+}
+/** The highest weight bucket a point may carry and still be drawn. */
+export declare function pointBucketLimit(detail: number, area: number): number;
+/** Rings smaller than this (steradians) are dropped, bar each region's largest. */
+export declare function polygonAreaLimit(detail: number, area: number): number;
+export interface GeoGeometryRequest {
+    /** Identifies `features` and `frame`: equal keys must mean equal selections. */
+    selectionKey: string;
+    features: readonly GeoFeature[];
+    frame: GeoFrame;
+    projection: GeoProjectionKind;
+    borders: GeoBorders;
+    detail: number;
+}
+/**
+ * The drawing for a selection, cached. The projection is fitted to the
+ * selection at full detail, so a `detail` tween never moves or rescales it.
+ */
+export declare function geoGeometry(request: GeoGeometryRequest): GeoGeometry | null;
+export declare function clearGeoGeometry(): void;
+//# sourceMappingURL=geometry.d.ts.map

package/dist/border/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/border/geometry.ts"],"names":[],"mappings":"AAaA,OAAO,EAAgC,KAAK,UAAU,EAAoC,MAAM,UAAU,CAAA;AAC1G,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAE3C,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,UAAU,GAAG,iBAAiB,GAAG,cAAc,CAAA;AACzF,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,SAAS,CAAA;AAE1C,MAAM,WAAW,UAAU;IACvB,2FAA2F;IAC3F,MAAM,EAAE,YAAY,CAAA;IACpB,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,WAAW;IACxB,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,UAAU,EAAE,CAAA;IACnB,KAAK,EAAE,UAAU,EAAE,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;CAChB;AA6BD,sEAAsE;AACtE,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAIrE;AAED,mFAAmF;AACnF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAGrE;AA+VD,MAAM,WAAW,kBAAkB;IAC/B,gFAAgF;IAChF,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAA;IAC/B,KAAK,EAAE,QAAQ,CAAA;IACf,UAAU,EAAE,iBAAiB,CAAA;IAC7B,OAAO,EAAE,UAAU,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;CACjB;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,WAAW,GAAG,IAAI,CAiB3E;AAED,wBAAgB,gBAAgB,IAAI,IAAI,CAGvC"}

package/dist/border/geometry.js

@@ -0,0 +1,382 @@
+import { geoArea, geoBounds, geoConicEqualArea, geoEquirectangular, geoMercator, geoOrthographic, geoPath, geoStream, } from "d3-geo";
+import { ringCoordinates } from "./format.js";
+const FIT = 1024;
+// `detail` maps onto a weight threshold that is a fraction of the selection's
+// own area, on a log scale — which is what makes a value look equally stylised
+// on Monaco and on Russia. 0 keeps points worth 1% of the area; just below 1,
+// points worth a billionth of it.
+const POINT_BASE = 2;
+const POINT_RANGE = 7;
+const POLYGON_BASE = 1.5;
+const POLYGON_RANGE = 6;
+const clamp01 = (value) => (value > 1 ? 1 : value > 0 ? value : 0);
+/** The highest weight bucket a point may carry and still be drawn. */
+export function pointBucketLimit(detail, area) {
+    if (detail >= 1 || !(area > 0))
+        return 255;
+    const minWeight = area * 10 ** -(POINT_BASE + POINT_RANGE * clamp01(detail));
+    return Math.floor(-2 * Math.log2(minWeight));
+}
+/** Rings smaller than this (steradians) are dropped, bar each region's largest. */
+export function polygonAreaLimit(detail, area) {
+    if (detail >= 1)
+        return 0;
+    return area * 10 ** -(POLYGON_BASE + POLYGON_RANGE * clamp01(detail));
+}
+function partsOf(features, frame) {
+    const parts = [];
+    for (const feature of features) {
+        const mainland = frame === "mainland" ? feature.polygons.filter((p) => p.mainland) : [];
+        const polygons = mainland.length > 0 ? mainland : feature.polygons;
+        let largest = null;
+        for (const polygon of polygons)
+            if (!largest || polygon.area > largest.area)
+                largest = polygon;
+        for (const polygon of polygons)
+            parts.push({ polygon, largest: polygon === largest });
+    }
+    return parts;
+}
+function centerLongitude(west, east) {
+    if (west <= east)
+        return (west + east) / 2;
+    const mid = (west + east + 360) / 2;
+    return mid > 180 ? mid - 360 : mid;
+}
+function makeProjection(kind, west, south, east, north) {
+    const lon = centerLongitude(west, east);
+    const lat = (south + north) / 2;
+    switch (kind) {
+        case "mercator":
+            return geoMercator().rotate([-lon, 0]);
+        case "equirectangular":
+            return geoEquirectangular().rotate([-lon, 0]);
+        case "orthographic":
+            return geoOrthographic().rotate([-lon, -lat]);
+        case "conic": {
+            const span = north - south;
+            return geoConicEqualArea()
+                .rotate([-lon, 0])
+                .center([0, lat])
+                .parallels([south + span / 6, north - span / 6]);
+        }
+    }
+}
+function fitFrame(kind, parts) {
+    if (parts.length === 0)
+        return null;
+    const shape = {
+        type: "MultiPolygon",
+        coordinates: parts.map(({ polygon }) => [ringCoordinates(polygon.rings[0])]),
+    };
+    const [[west, south], [east, north]] = geoBounds(shape);
+    for (const candidate of [kind, "equirectangular"]) {
+        const projection = makeProjection(candidate, west, south, east, north).fitSize([FIT, FIT], shape);
+        const [[x0, y0], [x1, y1]] = geoPath(projection).bounds(shape);
+        const size = Math.max(x1 - x0, y1 - y0);
+        if (!Number.isFinite(size) || size <= 0)
+            continue;
+        return {
+            projection,
+            centerX: (x0 + x1) / 2,
+            centerY: (y0 + y1) / 2,
+            size,
+            width: (x1 - x0) / size,
+            height: (y1 - y0) / size,
+        };
+    }
+    return null;
+}
+function project(frame, object, closed) {
+    const contours = [];
+    let current = null;
+    const { centerX, centerY, size } = frame;
+    const sink = {
+        point(x, y) {
+            current?.push((x - centerX) / size, -(y - centerY) / size);
+        },
+        lineStart() {
+            current = [];
+        },
+        lineEnd() {
+            const flat = current;
+            current = null;
+            if (!flat || flat.length < 4)
+                return;
+            let isClosed = closed;
+            if (!closed) {
+                const n = flat.length;
+                if (flat[0] === flat[n - 2] && flat[1] === flat[n - 1] && n >= 8) {
+                    flat.length = n - 2;
+                    isClosed = true;
+                }
+            }
+            const points = Float32Array.from(flat);
+            contours.push({ points, closed: isClosed, length: contourLength(points, isClosed) });
+        },
+        polygonStart() { },
+        polygonEnd() { },
+        sphere() { },
+    };
+    geoStream(object, frame.projection.stream(sink));
+    return contours;
+}
+function contourLength(points, closed) {
+    let length = 0;
+    const n = points.length / 2;
+    for (let i = 1; i < n; i++) {
+        length += Math.hypot(points[i * 2] - points[i * 2 - 2], points[i * 2 + 1] - points[i * 2 - 1]);
+    }
+    if (closed && n > 1)
+        length += Math.hypot(points[0] - points[n * 2 - 2], points[1] - points[n * 2 - 1]);
+    return length;
+}
+// Longest edge, in degrees, that simplification may leave. d3 takes an edge as
+// the short way round the sphere, so an edge across more than half the planet
+// (Kaliningrad to Chukotka, once the coast between is dropped) turns inside out.
+const MAX_EDGE_DEGREES = 20;
+/** Which of an arc's points survive `limit`, the same whichever way the arc is walked. */
+function keepMask(arc, limit) {
+    const n = arc.buckets.length;
+    const mask = new Uint8Array(n);
+    let lastLon = arc.points[0];
+    let lastLat = arc.points[1];
+    for (let i = 0; i < n; i++) {
+        const lon = arc.points[i * 2];
+        const lat = arc.points[i * 2 + 1];
+        let far = false;
+        if (arc.buckets[i] > limit) {
+            let dLon = Math.abs(lon - lastLon);
+            if (dLon > 180)
+                dLon = 360 - dLon;
+            far = Math.abs(lat - lastLat) > MAX_EDGE_DEGREES || dLon * Math.cos((lat * Math.PI) / 180) > MAX_EDGE_DEGREES;
+        }
+        if (arc.buckets[i] <= limit || far) {
+            mask[i] = 1;
+            lastLon = lon;
+            lastLat = lat;
+        }
+    }
+    return mask;
+}
+function filteredPoints(refs, maskFor) {
+    const out = [];
+    for (const { arc, reversed } of refs) {
+        const n = arc.buckets.length;
+        const mask = maskFor(arc);
+        for (let j = out.length === 0 ? 0 : 1; j < n; j++) {
+            const i = reversed ? n - 1 - j : j;
+            if (mask[i])
+                out.push([arc.points[i * 2], arc.points[i * 2 + 1]]);
+        }
+    }
+    return out;
+}
+/** A ring keeps at least three vertices, raising its arcs' limits if the global one would collapse it. */
+function ringLimit(ring, limit) {
+    let kept = 0;
+    for (const { arc } of ring) {
+        for (let i = 0; i < arc.buckets.length - 1; i++)
+            if (arc.buckets[i] <= limit)
+                kept++;
+    }
+    if (kept >= 3)
+        return limit;
+    const buckets = [];
+    for (const { arc } of ring)
+        for (let i = 0; i < arc.buckets.length - 1; i++)
+            buckets.push(arc.buckets[i]);
+    buckets.sort((a, b) => a - b);
+    return Math.max(limit, buckets[Math.min(2, buckets.length - 1)] ?? limit);
+}
+/**
+ * Whether a simplified ring still winds the way its original did. Dropping
+ * points can fold a small ring over itself, and d3 reads an exterior wound the
+ * wrong way as the rest of the planet — one such island fills the whole frame.
+ */
+function windsAsOriginal(ring, exterior) {
+    if (ring.length < 4)
+        return true;
+    const inverted = geoArea({ type: "Polygon", coordinates: [ring] }) > 2 * Math.PI;
+    return inverted !== exterior;
+}
+const endKey = (arc, last) => {
+    const i = last ? arc.buckets.length - 1 : 0;
+    return `${arc.points[i * 2]},${arc.points[i * 2 + 1]}`;
+};
+/** Joins arcs that meet end to end with nothing else at the joint, so a border draws as one line with real joins. */
+function chainArcs(arcs) {
+    const atNode = new Map();
+    for (const arc of arcs) {
+        for (const key of [endKey(arc, false), endKey(arc, true)]) {
+            const list = atNode.get(key);
+            if (list)
+                list.push(arc);
+            else
+                atNode.set(key, [arc]);
+        }
+    }
+    const visited = new Set();
+    const chains = [];
+    const refStart = ({ arc, reversed }) => endKey(arc, reversed);
+    const refEnd = ({ arc, reversed }) => endKey(arc, !reversed);
+    const nextAt = (node) => {
+        const list = atNode.get(node);
+        if (list.length !== 2)
+            return null;
+        return list.find((arc) => !visited.has(arc)) ?? null;
+    };
+    for (const arc of arcs) {
+        if (visited.has(arc))
+            continue;
+        visited.add(arc);
+        const refs = [{ arc, reversed: false }];
+        for (let next = nextAt(refEnd(refs[refs.length - 1])); next; next = nextAt(refEnd(refs[refs.length - 1]))) {
+            visited.add(next);
+            refs.push({ arc: next, reversed: endKey(next, false) !== refEnd(refs[refs.length - 1]) });
+        }
+        for (let prev = nextAt(refStart(refs[0])); prev; prev = nextAt(refStart(refs[0]))) {
+            visited.add(prev);
+            refs.unshift({ arc: prev, reversed: endKey(prev, true) !== refStart(refs[0]) });
+        }
+        chains.push({ refs, closed: refStart(refs[0]) === refEnd(refs[refs.length - 1]) });
+    }
+    return chains;
+}
+function buildGeometry(features, frame, fitted, borders, detail) {
+    const parts = partsOf(features, frame);
+    const area = parts.reduce((sum, { polygon }) => sum + polygon.area, 0);
+    const pointLimit = pointBucketLimit(detail, area);
+    const polygonLimit = polygonAreaLimit(detail, area);
+    const kept = [];
+    for (const { polygon, largest } of parts) {
+        if (!largest && polygon.area < polygonLimit)
+            continue;
+        kept.push(polygon.rings.filter((_, i) => i === 0 || polygon.ringAreas[i] >= polygonLimit));
+    }
+    const limits = new Map();
+    const usage = new Map();
+    for (const rings of kept) {
+        for (const ring of rings) {
+            const limit = ringLimit(ring, pointLimit);
+            for (const { arc } of ring) {
+                limits.set(arc.key, Math.max(limits.get(arc.key) ?? 0, limit));
+                const use = usage.get(arc.key);
+                if (use)
+                    use.count++;
+                else
+                    usage.set(arc.key, { arc, count: 1 });
+            }
+        }
+    }
+    const masks = new Map();
+    const maskFor = (arc) => {
+        let mask = masks.get(arc.key);
+        if (!mask) {
+            mask = keepMask(arc, limits.get(arc.key) ?? 255);
+            masks.set(arc.key, mask);
+        }
+        return mask;
+    };
+    if (pointLimit < 255) {
+        for (const rings of kept) {
+            rings.forEach((ring, index) => {
+                let limit = Math.min(...ring.map(({ arc }) => limits.get(arc.key) ?? pointLimit));
+                while (limit < 255 && !windsAsOriginal(filteredPoints(ring, maskFor), index === 0)) {
+                    limit = Math.min(255, limit + 2);
+                    for (const { arc } of ring) {
+                        limits.set(arc.key, Math.max(limits.get(arc.key) ?? 0, limit));
+                        masks.delete(arc.key);
+                    }
+                }
+            });
+        }
+    }
+    const fills = project(fitted, {
+        type: "MultiPolygon",
+        coordinates: kept.flatMap((rings) => {
+            const [exterior, ...holes] = rings.map((ring) => filteredPoints(ring, maskFor));
+            return exterior.length < 4 ? [] : [[exterior, ...holes.filter((hole) => hole.length >= 4)]];
+        }),
+    }, true);
+    const lineArcs = [...usage.values()].filter(({ count }) => borders === "all" || count === 1).map(({ arc }) => arc);
+    const lines = [];
+    for (const chain of chainArcs(lineArcs)) {
+        lines.push(...project(fitted, { type: "LineString", coordinates: filteredPoints(chain.refs, maskFor) }, false));
+    }
+    const sum = (contours) => contours.reduce((total, c) => total + c.length, 0);
+    const bytes = [...fills, ...lines].reduce((total, c) => total + c.points.byteLength + 32, 0);
+    return {
+        width: fitted.width,
+        height: fitted.height,
+        fills,
+        lines,
+        fillLength: sum(fills),
+        lineLength: sum(lines),
+        bytes,
+    };
+}
+class ByteCache {
+    _budget;
+    _entries = new Map();
+    _bytes = 0;
+    constructor(_budget) {
+        this._budget = _budget;
+    }
+    get(key) {
+        const value = this._entries.get(key);
+        if (value) {
+            this._entries.delete(key);
+            this._entries.set(key, value);
+        }
+        return value;
+    }
+    set(key, value) {
+        const previous = this._entries.get(key);
+        if (previous)
+            this._bytes -= previous.bytes;
+        this._entries.delete(key);
+        this._entries.set(key, value);
+        this._bytes += value.bytes;
+        for (const [oldest, entry] of this._entries) {
+            if (this._bytes <= this._budget || this._entries.size <= 1)
+                break;
+            this._entries.delete(oldest);
+            this._bytes -= entry.bytes;
+        }
+    }
+    clear() {
+        this._entries.clear();
+        this._bytes = 0;
+    }
+}
+const frames = new ByteCache(64);
+const geometries = new ByteCache(64 * 1024 * 1024);
+/**
+ * The drawing for a selection, cached. The projection is fitted to the
+ * selection at full detail, so a `detail` tween never moves or rescales it.
+ */
+export function geoGeometry(request) {
+    const detail = Math.round(clamp01(request.detail) * 100) / 100;
+    const frameKey = `${request.selectionKey}|${request.projection}`;
+    const key = `${frameKey}|${request.borders}|${detail}`;
+    const cached = geometries.get(key);
+    if (cached)
+        return cached;
+    let fitted = frames.get(frameKey);
+    if (!fitted) {
+        const made = fitFrame(request.projection, partsOf(request.features, request.frame));
+        if (!made)
+            return null;
+        fitted = made;
+        frames.set(frameKey, { ...made, bytes: 1 });
+    }
+    const geometry = buildGeometry(request.features, request.frame, fitted, request.borders, detail);
+    geometries.set(key, geometry);
+    return geometry;
+}
+export function clearGeoGeometry() {
+    frames.clear();
+    geometries.clear();
+}
+//# sourceMappingURL=geometry.js.map