@sjvair/map-sdk 0.0.0-stage → 0.1.0-beta.1

package/dist/presets/fire-groups.js

@@ -0,0 +1,51 @@
+import clustersDbscan from "@turf/clusters-dbscan";
+import { featureCollection, point } from "@turf/helpers";
+// Ported from monitor-map 4.3.0 (src/lib/hms/hms.svelte.ts, computeFireGroups).
+/** Fires within this distance (km) of each other share a group. */
+const EPSILON_KM = 2;
+const MIN_POINTS = 1;
+const mean = (values) => values.reduce((s, v) => s + v, 0) / values.length;
+/**
+ * Drops fires without a finite FRP, then keeps one fire per exact coordinates: the latest by
+ * timestamp, else the first listed. Dropping first means a newer fire with no FRP hides nothing.
+ */
+export function cleanFires(fires) {
+    const latest = new Map();
+    for (const fire of fires) {
+        if (!Number.isFinite(fire.frp))
+            continue;
+        const key = `${fire.coordinates[0]},${fire.coordinates[1]}`;
+        const existing = latest.get(key);
+        if (!existing || (fire.timestamp ?? "") > (existing.timestamp ?? ""))
+            latest.set(key, fire);
+    }
+    return [...latest.values()];
+}
+/**
+ * Groups nearby fires (DBSCAN, 2 km, every fire its own seed) into one point per group, after
+ * skipping fires without a finite FRP and keeping one fire per coordinates, as monitor-map does.
+ */
+export function groupFires(fires) {
+    const usable = cleanFires(fires);
+    if (!usable.length)
+        return [];
+    const clustered = clustersDbscan(featureCollection(usable.map((f) => point(f.coordinates, { fireId: f.id, frp: f.frp }))), EPSILON_KM, { minPoints: MIN_POINTS, units: "kilometers" });
+    const groups = new Map();
+    for (const feature of clustered.features) {
+        const props = feature.properties;
+        // With minPoints 1 every fire is a core point, so "noise" never occurs.
+        const key = props.dbscan === "noise" ? `noise-${props.fireId}` : `cluster-${props.cluster}`;
+        const [lng, lat] = feature.geometry.coordinates;
+        const entry = groups.get(key) ?? { frps: [], lngs: [], lats: [] };
+        entry.frps.push(props.frp);
+        entry.lngs.push(lng);
+        entry.lats.push(lat);
+        groups.set(key, entry);
+    }
+    return [...groups].map(([key, { frps, lngs, lats }]) => ({
+        id: `hms-fire-group-${key}`,
+        coordinates: [mean(lngs), mean(lats)],
+        avgFrp: mean(frps),
+        count: frps.length
+    }));
+}

package/dist/presets/forecast-zones.d.ts

@@ -0,0 +1,25 @@
+import type { MapPlugin } from "../core/plugin.js";
+import type { DataSource } from "../data/types.js";
+export interface ForecastZonesPluginOptions {
+    /** Default "forecast-zones". */
+    id?: string;
+    source: DataSource;
+    /** Already-translated layer name for the list and summary. */
+    layerLabel: string;
+    /** Default true. */
+    selectable?: boolean;
+}
+/**
+ * Air quality forecast zones filled by the forecast's AQI level.
+ *
+ * The source's `scale` is expected to be the ScaleRef
+ * `{ dataset: "forecasts", entryType: "aqi-forecast" }`.
+ *
+ * This preset does not fetch. The host's data source supplies the features, and each feature's
+ * `refKey` must already be `region:<type>:<external_id>`: a county region
+ * (`region:county:<code>`) for most zones and a `custom` region for the rest (e.g.
+ * `region:custom:sjvapcd-kern-airbasin`). Use the region's `external_id` (its code), never the
+ * server's `id` (a sqid), which is not a ref. A picked feature selects
+ * `{ kind: "regions", ids: ["<type>:<code>"] }`.
+ */
+export declare function forecastZonesPlugin(options: ForecastZonesPluginOptions): MapPlugin;

package/dist/presets/forecast-zones.js

@@ -0,0 +1,23 @@
+import { shapesPlugin } from "../plugins/shapes.svelte.js";
+/**
+ * Air quality forecast zones filled by the forecast's AQI level.
+ *
+ * The source's `scale` is expected to be the ScaleRef
+ * `{ dataset: "forecasts", entryType: "aqi-forecast" }`.
+ *
+ * This preset does not fetch. The host's data source supplies the features, and each feature's
+ * `refKey` must already be `region:<type>:<external_id>`: a county region
+ * (`region:county:<code>`) for most zones and a `custom` region for the rest (e.g.
+ * `region:custom:sjvapcd-kern-airbasin`). Use the region's `external_id` (its code), never the
+ * server's `id` (a sqid), which is not a ref. A picked feature selects
+ * `{ kind: "regions", ids: ["<type>:<code>"] }`.
+ */
+export function forecastZonesPlugin(options) {
+    return shapesPlugin({
+        id: options.id ?? "forecast-zones",
+        source: options.source,
+        layerLabel: options.layerLabel,
+        mode: "choropleth",
+        selectable: options.selectable ?? true
+    });
+}

package/dist/presets/hms-fire.d.ts

@@ -0,0 +1,26 @@
+import type { MapPlugin } from "../core/plugin.js";
+import type { DataSource } from "../data/types.js";
+export interface HmsFirePluginOptions {
+    /** Default "hms-fire". */
+    id?: string;
+    /** The fires, or with `hotspots` the groups shown below zoom 10 (listed). */
+    source: DataSource;
+    /** Single detections shown from zoom 10 instead of `source` (not listed). Default: none. */
+    hotspots?: DataSource;
+    /** Already-translated layer name for the list and summary. */
+    layerLabel: string;
+}
+/**
+ * NOAA HMS fire detections as flame icons colored by fire radiative power (MW) and growing with
+ * its level. Not selectable; `source`'s fires are listed.
+ *
+ * With `hotspots`, it is still one layer (one legend section, one list) that switches by itself
+ * while zooming: `source` (groups from `groupFires`, value = `avgFrp`) below zoom 10, `hotspots`
+ * (each detection) from zoom 10. Both are hit-tested and show the same tooltip (name, value,
+ * level);
+ * only the groups are listed.
+ *
+ * The sources' `scale` is expected to be the ScaleRef `{ dataset: "hms-fire", entryType:
+ * "fire-frp" }`, and each feature's `value` its FRP. This preset does not fetch.
+ */
+export declare function hmsFirePlugin(options: HmsFirePluginOptions): MapPlugin;

package/dist/presets/hms-fire.js

@@ -0,0 +1,87 @@
+import { scopedContext } from "../core/scoped-context.js";
+import { fireIcon } from "../plugins/icons.js";
+import { pointsPlugin } from "../plugins/points.svelte.js";
+import TooltipItem from "../ui/TooltipItem.svelte";
+import { componentSnippet } from "./monitors.js";
+/** The zoom where `hotspots` replace the groups (inclusive), as sjvair.com's map does. */
+const HOTSPOT_ZOOM = 10;
+/** Icon size in pixels by level index, smallest to largest (presentation). */
+const SIZES = [20, 24, 28, 32, 36];
+const CANVAS = SIZES[SIZES.length - 1];
+/** The fire glyph at the size for a level index, centered on a fixed canvas. */
+function drawFire(color, levelIndex = -1) {
+    const size = SIZES[Math.min(Math.max(levelIndex, 0), SIZES.length - 1)];
+    const offset = (CANVAS - size) / 2;
+    return `<svg width="${CANVAS}" height="${CANVAS}" viewBox="0 0 ${CANVAS} ${CANVAS}" xmlns="http://www.w3.org/2000/svg"><g transform="translate(${offset} ${offset})">${fireIcon(color, size)}</g></svg>`;
+}
+function firePoints(id, source, layerLabel, zoomRange) {
+    return pointsPlugin({
+        id,
+        source,
+        layerLabel,
+        selectable: false,
+        zoomRange,
+        legendDisplay: "blocks",
+        icon: {
+            category: () => "fire",
+            draw: (_category, color, _theme, levelIndex) => drawFire(color, levelIndex),
+            size: CANVAS
+        }
+    });
+}
+/**
+ * NOAA HMS fire detections as flame icons colored by fire radiative power (MW) and growing with
+ * its level. Not selectable; `source`'s fires are listed.
+ *
+ * With `hotspots`, it is still one layer (one legend section, one list) that switches by itself
+ * while zooming: `source` (groups from `groupFires`, value = `avgFrp`) below zoom 10, `hotspots`
+ * (each detection) from zoom 10. Both are hit-tested and show the same tooltip (name, value,
+ * level);
+ * only the groups are listed.
+ *
+ * The sources' `scale` is expected to be the ScaleRef `{ dataset: "hms-fire", entryType:
+ * "fire-frp" }`, and each feature's `value` its FRP. This preset does not fetch.
+ */
+export function hmsFirePlugin(options) {
+    const id = options.id ?? "hms-fire";
+    const { source, hotspots, layerLabel } = options;
+    if (!hotspots)
+        return firePoints(id, source, layerLabel);
+    // Both inner plugins share the outer id, so their hits are this plugin's.
+    const groups = firePoints(id, source, layerLabel, { max: HOTSPOT_ZOOM });
+    const singles = firePoints(id, hotspots, layerLabel, { min: HOTSPOT_ZOOM });
+    // The providers of the running setup, for the hotspots' tooltips.
+    let ctxNow = null;
+    return {
+        id,
+        label: layerLabel,
+        get dataset() {
+            return groups.dataset;
+        },
+        selectable: false,
+        setup(ctx) {
+            ctxNow = ctx;
+            const teardownGroups = groups.setup(scopedContext(ctx, "groups:"));
+            const teardownSingles = singles.setup(scopedContext(ctx, "hotspots:"));
+            return () => {
+                ctxNow = null;
+                teardownSingles();
+                teardownGroups();
+            };
+        },
+        legend: groups.legend,
+        // Only the groups are listed; a hovered hotspot shows what a group's hover does: its name
+        // (the generic header) with its value and level.
+        features: groups.features,
+        hoverTooltip(hit) {
+            const item = singles.features?.().find((f) => f.refKey === hit.refKey);
+            if (!item || !ctxNow)
+                return undefined;
+            return componentSnippet(TooltipItem, {
+                item,
+                messages: ctxNow.messages,
+                format: ctxNow.format
+            });
+        }
+    };
+}

package/dist/presets/hms-smoke.d.ts

@@ -0,0 +1,19 @@
+import type { MapPlugin } from "../core/plugin.js";
+import type { DataSource } from "../data/types.js";
+export interface HmsSmokePluginOptions {
+    /** Default "hms-smoke". */
+    id?: string;
+    source: DataSource;
+    /** Already-translated layer name for the legend and summary. */
+    layerLabel: string;
+}
+/**
+ * NOAA HMS smoke plumes: polygons filled and outlined (`outline: "level"`) by density, using each
+ * level's opacity. Not selectable; listed (each plume a row with its density level), so plumes
+ * can be reached without a mouse.
+ *
+ * The source's `scale` is expected to be the ScaleRef
+ * `{ dataset: "hms-smoke", entryType: "smoke-density" }`, and each feature's `value` its density
+ * key ("light", "medium", "heavy"). This preset does not fetch.
+ */
+export declare function hmsSmokePlugin(options: HmsSmokePluginOptions): MapPlugin;

package/dist/presets/hms-smoke.js

@@ -0,0 +1,20 @@
+import { shapesPlugin } from "../plugins/shapes.svelte.js";
+/**
+ * NOAA HMS smoke plumes: polygons filled and outlined (`outline: "level"`) by density, using each
+ * level's opacity. Not selectable; listed (each plume a row with its density level), so plumes
+ * can be reached without a mouse.
+ *
+ * The source's `scale` is expected to be the ScaleRef
+ * `{ dataset: "hms-smoke", entryType: "smoke-density" }`, and each feature's `value` its density
+ * key ("light", "medium", "heavy"). This preset does not fetch.
+ */
+export function hmsSmokePlugin(options) {
+    return shapesPlugin({
+        id: options.id ?? "hms-smoke",
+        source: options.source,
+        layerLabel: options.layerLabel,
+        mode: "choropleth",
+        selectable: false,
+        outline: "level"
+    });
+}

package/dist/presets/monitors.d.ts

@@ -0,0 +1,48 @@
+import { type Component, type Snippet } from "svelte";
+import type { MapPlugin } from "../core/plugin.js";
+import type { MetadataProvider } from "../data/metadata.js";
+import type { DataSource, MonitorFeatureProperties } from "../data/types.js";
+import { circle, square, triangle } from "../plugins/icons.js";
+export declare const MONITOR_INACTIVE_COLOR = "#969696";
+export declare const MONITOR_INSIDE_OUTLINE = "#000000";
+export interface MonitorsPluginOptions {
+    /** Default "monitors". */
+    id?: string;
+    source: DataSource<MonitorFeatureProperties>;
+    /** Already-translated layer name for the list and summary. */
+    layerLabel: string;
+    /** Default true, like the shape presets. */
+    selectable?: boolean;
+    /** "ring" (default): ring and check mark. "enlarge": the selected icon draws at 1.3x. */
+    selectedStyle?: "ring" | "enlarge";
+    /** Cluster each monitor type below zoom 9. Default true. */
+    clustered?: boolean;
+}
+export type MonitorShape = "circle" | "square" | "triangle";
+/** The marker shape for a monitor type: reference monitors are triangles, sensors circles. */
+export declare function monitorShape(type: string): MonitorShape;
+/** The marker drawing for each shape. */
+export declare const SHAPES: {
+    circle: typeof circle;
+    square: typeof square;
+    triangle: typeof triangle;
+};
+/**
+ * A snippet that mounts `component` with `props` (a tooltip outside the map's component tree).
+ * It mounts at once; `late`, when given, updates the props once it resolves (e.g. a note that
+ * needs a lookup), so a slow lookup never leaves an empty card. Nothing is mounted or updated
+ * after the tooltip closes, and a failure to mount or update is logged, not thrown.
+ */
+export declare function componentSnippet<Props extends Record<string, any>>(component: Component<Props>, props: Props, late?: Promise<Partial<Props>>): Snippet;
+/**
+ * Looks up a monitor type's reporting interval (e.g. "1 hour") for tooltips' "(N avg)" note,
+ * once per type; null when the provider has none. Failures (a rejection or a synchronous throw)
+ * give null and are forgotten, so they're retried.
+ */
+export declare function intervalLookup(): (type: string, metadata: MetadataProvider) => Promise<string | null>;
+/**
+ * Air-quality monitors as on today's live map: a shape per monitor type filled with its level's
+ * color, inactive monitors in the neutral color, inside monitors outlined, and per-type clusters
+ * colored by their average that zoom in when clicked.
+ */
+export declare function monitorsPlugin(options: MonitorsPluginOptions): MapPlugin;

package/dist/presets/monitors.js

@@ -0,0 +1,243 @@
+import { createRawSnippet, mount, unmount } from "svelte";
+import { circle, square, triangle } from "../plugins/icons.js";
+import { pointsPlugin } from "../plugins/points.svelte.js";
+import { hasNumericValue, levelKeyExpression, levelLookup, MISSING_VALUE } from "../plugins/style.js";
+import { levelChip } from "../ui/level-chip.js";
+import { reactiveProps } from "./reactive-props.svelte.js";
+import MonitorClusterTooltip from "./MonitorClusterTooltip.svelte";
+import MonitorTooltip from "./MonitorTooltip.svelte";
+// Ported from monitor-map 4.3.0 (src/lib/monitors/): shapes, draw order, icon variants, and
+// cluster rendering. Shapes, sizes, and order are presentation; colors come from the scale and
+// the theme, except the two fixed monitor colors below.
+// The user's decision (2026-11-04), an exception to the theme-token rule: inactive monitors are
+// this gray and inside monitors have a black outline, on every map and theme, as on sjvair.com.
+export const MONITOR_INACTIVE_COLOR = "#969696";
+export const MONITOR_INSIDE_OUTLINE = "#000000";
+/** The marker shape for a monitor type: reference monitors are triangles, sensors circles. */
+export function monitorShape(type) {
+    switch (type) {
+        case "airnow":
+        case "aqview":
+        case "bam1022":
+        case "aqlite":
+            return "triangle";
+        default:
+            return "circle";
+    }
+}
+/** monitor-map's draw order (`getOrder`): higher draws on top. Unknown types draw lowest. */
+function monitorOrder(props) {
+    switch (props.type) {
+        case "airgradient":
+            return 5;
+        case "airnow":
+            return 2;
+        case "aqview":
+            return 3;
+        case "bam1022":
+            return 6;
+        case "purpleair":
+            return props.isSjvair ? 4 : 1;
+        case "vozbox":
+            return 7;
+        case "aqlite":
+            return 8;
+        default:
+            return 0;
+    }
+}
+/** The marker drawing for each shape. */
+export const SHAPES = { circle, square, triangle };
+const ICON_SIZE = 24;
+const BORDER_WIDTH = 2;
+const CLUSTER_RADIUS = 40;
+const CLUSTER_MAX_ZOOM = 9;
+const CLUSTER_OPACITY = 0.8;
+/** Cluster icons grow with the count: 1.3×, then 1.6× from 10, then 2× from 25. */
+const CLUSTER_SIZES = [1.3, 10, 1.6, 25, 2.0];
+/** `shape:location`, e.g. "triangle:inside". */
+function category(props) {
+    return `${monitorShape(props.type)}:${props.location === "inside" ? "inside" : "outside"}`;
+}
+/** Readings by `numericValue`'s rule (numbers and numeric strings), as levels and tooltips count. */
+const IS_READING = hasNumericValue("value");
+const COUNT = ["get", "countValues"];
+const MEAN = ["/", ["get", "sumValues"], ["max", COUNT, 1]];
+/** The cluster's average reading, or MISSING_VALUE when none of its monitors has one. */
+const AVERAGE = ["case", [">", COUNT, 0], MEAN, MISSING_VALUE];
+/** Readable text on `color`, or `fallback` for an unparseable color. */
+function readable(color, fallback) {
+    return levelChip(color)?.text ?? fallback;
+}
+/** A type's cluster: its shape colored by the average's level, with the rounded average on it. */
+function clusterLayers({ group, sourceId, scale, theme, iconImage, iconSizeScale }) {
+    const filter = ["has", "point_count"];
+    const sizes = CLUSTER_SIZES.map((n, i) => (i % 2 === 0 ? n * iconSizeScale : n));
+    return [
+        {
+            local: "cluster-icon",
+            spec: {
+                type: "symbol",
+                source: sourceId,
+                filter,
+                layout: {
+                    "icon-image": iconImage(`${monitorShape(group)}:outside`, levelKeyExpression(scale, AVERAGE)),
+                    "icon-size": [
+                        "step",
+                        ["get", "point_count"],
+                        ...sizes
+                    ],
+                    "icon-ignore-placement": true,
+                    "icon-allow-overlap": true
+                },
+                paint: { "icon-opacity": CLUSTER_OPACITY }
+            }
+        },
+        {
+            local: "cluster-average",
+            spec: {
+                type: "symbol",
+                source: sourceId,
+                filter,
+                layout: {
+                    "text-field": [
+                        "case",
+                        [">", COUNT, 0],
+                        ["to-string", ["round", MEAN]],
+                        ""
+                    ],
+                    "text-size": 12,
+                    "text-ignore-placement": true,
+                    "text-allow-overlap": true
+                },
+                paint: {
+                    "text-color": levelLookup(scale, AVERAGE, readable(theme.neutral, theme.foreground), (l) => readable(l.color || theme.neutral, theme.foreground))
+                }
+            }
+        }
+    ];
+}
+/**
+ * A snippet that mounts `component` with `props` (a tooltip outside the map's component tree).
+ * It mounts at once; `late`, when given, updates the props once it resolves (e.g. a note that
+ * needs a lookup), so a slow lookup never leaves an empty card. Nothing is mounted or updated
+ * after the tooltip closes, and a failure to mount or update is logged, not thrown.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function componentSnippet(component, props, late) {
+    return createRawSnippet(() => ({
+        render: () => "<div></div>",
+        setup(target) {
+            let instance;
+            let closed = false;
+            const live = reactiveProps(props);
+            try {
+                instance = mount(component, { target, props: live });
+            }
+            catch (error) {
+                console.error("map-sdk: a tooltip failed to mount", error);
+            }
+            void late?.then((extra) => {
+                if (closed || !instance)
+                    return;
+                try {
+                    Object.assign(live, extra);
+                }
+                catch (error) {
+                    console.error("map-sdk: a tooltip failed to update", error);
+                }
+            });
+            return () => {
+                closed = true;
+                if (instance)
+                    void unmount(instance);
+            };
+        }
+    }));
+}
+/**
+ * Looks up a monitor type's reporting interval (e.g. "1 hour") for tooltips' "(N avg)" note,
+ * once per type; null when the provider has none. Failures (a rejection or a synchronous throw)
+ * give null and are forgotten, so they're retried.
+ */
+export function intervalLookup() {
+    const intervals = new Map();
+    return function intervalFor(type, metadata) {
+        if (!metadata.monitorTypeInterval)
+            return Promise.resolve(null);
+        let found = intervals.get(type);
+        if (!found) {
+            let call;
+            try {
+                call = Promise.resolve(metadata.monitorTypeInterval(type));
+            }
+            catch {
+                return Promise.resolve(null);
+            }
+            const lookup = call.then((value) => (value === "unavailable" ? null : value), () => null);
+            found = lookup;
+            intervals.set(type, lookup);
+            void lookup.then((value) => {
+                if (value === null && intervals.get(type) === lookup)
+                    intervals.delete(type);
+            });
+        }
+        return found;
+    };
+}
+/**
+ * Air-quality monitors as on today's live map: a shape per monitor type filled with its level's
+ * color, inactive monitors in the neutral color, inside monitors outlined, and per-type clusters
+ * colored by their average that zoom in when clicked.
+ */
+export function monitorsPlugin(options) {
+    const clustered = options.clustered ?? true;
+    const intervalFor = intervalLookup();
+    return pointsPlugin({
+        id: options.id ?? "monitors",
+        source: options.source,
+        layerLabel: options.layerLabel,
+        legendTitle: "entry-type",
+        selectable: options.selectable ?? true,
+        selectedStyle: options.selectedStyle,
+        icon: {
+            category,
+            draw(cat, color) {
+                const [shape, location] = cat.split(":");
+                return SHAPES[shape](color, BORDER_WIDTH, location === "inside" ? MONITOR_INSIDE_OUTLINE : undefined);
+            },
+            size: ICON_SIZE,
+            muted: (props) => !props.isActive,
+            mutedColor: MONITOR_INACTIVE_COLOR
+        },
+        sortKey: monitorOrder,
+        cluster: clustered
+            ? {
+                radius: CLUSTER_RADIUS,
+                maxZoom: CLUSTER_MAX_ZOOM,
+                groupBy: (props) => props.type,
+                properties: {
+                    sumValues: ["+", ["case", IS_READING, ["to-number", ["get", "value"], 0], 0]],
+                    countValues: ["+", ["case", IS_READING, 1, 0]]
+                },
+                layers: clusterLayers,
+                tooltip: (cluster, env) => componentSnippet(MonitorClusterTooltip, {
+                    cluster,
+                    scale: env.scale,
+                    messages: env.messages,
+                    format: env.format,
+                    metadata: env.metadata
+                })
+            }
+            : undefined,
+        tooltipShowsName: true,
+        tooltip: (item, props, env) => componentSnippet(MonitorTooltip, {
+            item,
+            timestamp: props.timestamp ?? null,
+            scale: env.scale,
+            messages: env.messages,
+            format: env.format,
+            interval: null
+        }, intervalFor(props.type, env.metadata).then((interval) => ({ interval })))
+    });
+}

package/dist/presets/reactive-props.svelte.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Props for a component mounted outside the map's tree that can be updated by assigning to them.
+ */
+export declare function reactiveProps<T extends object>(initial: T): T;

package/dist/presets/reactive-props.svelte.js

@@ -0,0 +1,7 @@
+/**
+ * Props for a component mounted outside the map's tree that can be updated by assigning to them.
+ */
+export function reactiveProps(initial) {
+    const props = $state(initial);
+    return props;
+}

package/dist/presets/regions.d.ts

@@ -0,0 +1,24 @@
+import type { MapPlugin } from "../core/plugin.js";
+import type { DataSource } from "../data/types.js";
+export interface RegionsPluginOptions {
+    /** Default "regions". */
+    id?: string;
+    source: DataSource;
+    /** Already-translated layer name for the list and summary. */
+    layerLabel: string;
+    /** Default true. */
+    selectable?: boolean;
+}
+/**
+ * Region polygons (counties, cities, and other server regions) filled by a pollutant's level.
+ *
+ * The source's `scale` is expected to be the ScaleRef
+ * `{ dataset: "air-quality", entryType: <pollutant> }` (e.g. `pm25`).
+ *
+ * This preset does not fetch. The host's data source supplies the features, and each feature's
+ * `refKey` must already be `region:<type>:<external_id>`: a region of any type, e.g.
+ * `region:county:fresno`. Use the region's `external_id` (its code), never the server's `id` (a
+ * sqid), which is not a ref. A picked feature selects
+ * `{ kind: "regions", ids: ["<type>:<code>"] }`.
+ */
+export declare function regionsPlugin(options: RegionsPluginOptions): MapPlugin;

package/dist/presets/regions.js

@@ -0,0 +1,22 @@
+import { shapesPlugin } from "../plugins/shapes.svelte.js";
+/**
+ * Region polygons (counties, cities, and other server regions) filled by a pollutant's level.
+ *
+ * The source's `scale` is expected to be the ScaleRef
+ * `{ dataset: "air-quality", entryType: <pollutant> }` (e.g. `pm25`).
+ *
+ * This preset does not fetch. The host's data source supplies the features, and each feature's
+ * `refKey` must already be `region:<type>:<external_id>`: a region of any type, e.g.
+ * `region:county:fresno`. Use the region's `external_id` (its code), never the server's `id` (a
+ * sqid), which is not a ref. A picked feature selects
+ * `{ kind: "regions", ids: ["<type>:<code>"] }`.
+ */
+export function regionsPlugin(options) {
+    return shapesPlugin({
+        id: options.id ?? "regions",
+        source: options.source,
+        layerLabel: options.layerLabel,
+        mode: "choropleth",
+        selectable: options.selectable ?? true
+    });
+}

package/dist/stores/abort.d.ts

@@ -0,0 +1,16 @@
+export type SignalOptions = {
+    signal?: AbortSignal;
+};
+/**
+ * A signal that aborts as soon as any input does, with that input's reason. Already aborted if
+ * any input is. Undefined inputs are ignored. Call `dispose()` to drop the listeners.
+ */
+export declare function anySignal(...signals: Array<AbortSignal | undefined>): {
+    signal: AbortSignal;
+    dispose(): void;
+};
+/**
+ * Settles like `promise`, unless `signal` aborts first, in which case it rejects with
+ * `signal.reason`. The inner promise's later outcome is swallowed.
+ */
+export declare function untilAborted<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T>;