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

package/dist/presets/MonitorTooltip.svelte

@@ -0,0 +1,88 @@
+<script lang="ts">
+	import { formatValue } from "../ui/value-format.js";
+	import type { FeatureListItem } from "../core/plugin.js";
+	import type { FormatProvider } from "../data/format.js";
+	import type { MessageProvider } from "../data/messages.js";
+	import { NO_LEVEL, numericValue } from "../data/scale.js";
+	import type { Scale } from "../data/scale-types.js";
+	import MonitorReadingBox from "./MonitorReadingBox.svelte";
+
+	// Ported from monitor-map's MonitorTooltip: the reading in a level-colored box beside when it
+	// was taken, the monitor's name, and how long ago. The whole number is cut off, not rounded, as
+	// monitor-map's is; the level label is added for accessibility. The map tooltip leaves its own
+	// name header out.
+
+	interface Props {
+		item: FeatureListItem;
+		/** ISO 8601, or null when unknown. */
+		timestamp: string | null;
+		scale: Scale | null;
+		messages: MessageProvider;
+		format: FormatProvider;
+		/**
+		 * How often the monitor's type reports (e.g. "1 hour"); null leaves the "(N avg)" note
+		 * out.
+		 */
+		interval: string | null;
+	}
+
+	let { item, timestamp, scale, messages, format, interval }: Props = $props();
+
+	// A level with an empty color shows its label in the neutral box.
+	const level = $derived(item.level !== NO_LEVEL ? item.level : null);
+	const reading = $derived.by(() => {
+		const n = numericValue(item.value);
+		return n === null ? null : formatValue(Math.trunc(n), 0, format);
+	});
+	const time = $derived.by(() => {
+		if (!timestamp || Number.isNaN(Date.parse(timestamp))) return null;
+		const formatted = format.dateTime(timestamp);
+		const zone = format.zoneLabel();
+		return {
+			at: zone ? messages("mapsdk_time_with_zone", { time: formatted, zone }) : formatted,
+			ago: messages("mapsdk_monitor_updated", { when: format.relativeTime(timestamp) })
+		};
+	});
+</script>
+
+<div class="mapsdk-monitor-tip mapsdk-tooltip-wide">
+	<MonitorReadingBox
+		color={level?.color || null}
+		header={scale?.label ?? ""}
+		value={reading ?? messages("mapsdk_no_reading")}
+		large={reading !== null}
+		subheading={interval ? messages("mapsdk_monitor_interval_avg", { interval }) : undefined}
+	/>
+	<div class="mapsdk-monitor-detail">
+		{#if time}
+			<span>{time.at}</span>
+		{/if}
+		<span class="mapsdk-monitor-name text-lg">{item.name}</span>
+		<span>{level ? level.label : messages("mapsdk_no_level")}</span>
+		{#if time}
+			<span class="mapsdk-monitor-ago text-base">{time.ago}</span>
+		{/if}
+	</div>
+</div>
+
+<style>
+	.mapsdk-monitor-tip {
+		display: flex;
+		gap: 0.5rem;
+	}
+
+	.mapsdk-monitor-name {
+		font-weight: 700;
+		text-decoration: underline;
+	}
+
+	.mapsdk-monitor-ago {
+		margin-top: auto;
+	}
+
+	.mapsdk-monitor-detail {
+		display: flex;
+		flex-direction: column;
+		gap: 0.25rem;
+	}
+</style>

package/dist/presets/MonitorTooltip.svelte.d.ts

@@ -0,0 +1,20 @@
+import type { FeatureListItem } from "../core/plugin.js";
+import type { FormatProvider } from "../data/format.js";
+import type { MessageProvider } from "../data/messages.js";
+import type { Scale } from "../data/scale-types.js";
+interface Props {
+    item: FeatureListItem;
+    /** ISO 8601, or null when unknown. */
+    timestamp: string | null;
+    scale: Scale | null;
+    messages: MessageProvider;
+    format: FormatProvider;
+    /**
+     * How often the monitor's type reports (e.g. "1 hour"); null leaves the "(N avg)" note
+     * out.
+     */
+    interval: string | null;
+}
+declare const MonitorTooltip: import("svelte").Component<Props, {}, "">;
+type MonitorTooltip = ReturnType<typeof MonitorTooltip>;
+export default MonitorTooltip;

package/dist/presets/calheatscore.d.ts

@@ -0,0 +1,24 @@
+import type { MapPlugin } from "../core/plugin.js";
+import type { DataSource } from "../data/types.js";
+export interface CalHeatScorePluginOptions {
+    /** Default "calheatscore". */
+    id?: string;
+    source: DataSource;
+    /** Already-translated layer name for the list and summary. */
+    layerLabel: string;
+    /** Default true. */
+    selectable?: boolean;
+}
+/**
+ * CalHeatScore ZIP code areas filled by their heat score.
+ *
+ * The source's `scale` is expected to be the ScaleRef
+ * `{ dataset: "calheatscore", entryType: "heat-score" }`.
+ *
+ * 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 ZIP, `region:zipcode:<zip>`, e.g.
+ * `region:zipcode:93721` (`zipcode` is the server's region type name). 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 calHeatScorePlugin(options: CalHeatScorePluginOptions): MapPlugin;

package/dist/presets/calheatscore.js

@@ -0,0 +1,22 @@
+import { shapesPlugin } from "../plugins/shapes.svelte.js";
+/**
+ * CalHeatScore ZIP code areas filled by their heat score.
+ *
+ * The source's `scale` is expected to be the ScaleRef
+ * `{ dataset: "calheatscore", entryType: "heat-score" }`.
+ *
+ * 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 ZIP, `region:zipcode:<zip>`, e.g.
+ * `region:zipcode:93721` (`zipcode` is the server's region type name). 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 calHeatScorePlugin(options) {
+    return shapesPlugin({
+        id: options.id ?? "calheatscore",
+        source: options.source,
+        layerLabel: options.layerLabel,
+        mode: "choropleth",
+        selectable: options.selectable ?? true
+    });
+}

package/dist/presets/cluster-area.d.ts

@@ -0,0 +1,13 @@
+type Point = [number, number];
+/**
+ * The convex hull of lng/lat points (monotone chain): counter-clockwise, without a repeated
+ * closing point, inner and collinear points dropped. Fewer than 3 points means no area.
+ */
+export declare function convexHull(points: Point[]): Point[];
+/**
+ * The area, in square miles, of the smallest shape around a cluster's monitors (their convex
+ * hull), as sjvair.com's map computed area: `@turf/area`, then `convertArea`. 0 for fewer than 3
+ * points not on one line.
+ */
+export declare function clusterAreaSqMiles(points: Point[]): number;
+export {};

package/dist/presets/cluster-area.js

@@ -0,0 +1,34 @@
+import area from "@turf/area";
+import { convertArea, polygon } from "@turf/helpers";
+const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+/**
+ * The convex hull of lng/lat points (monotone chain): counter-clockwise, without a repeated
+ * closing point, inner and collinear points dropped. Fewer than 3 points means no area.
+ */
+export function convexHull(points) {
+    const sorted = [...points].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+    if (sorted.length < 3)
+        return sorted;
+    const half = (from) => {
+        const chain = [];
+        for (const p of from) {
+            while (chain.length >= 2 && cross(chain[chain.length - 2], chain[chain.length - 1], p) <= 0)
+                chain.pop();
+            chain.push(p);
+        }
+        chain.pop();
+        return chain;
+    };
+    return [...half(sorted), ...half([...sorted].reverse())];
+}
+/**
+ * The area, in square miles, of the smallest shape around a cluster's monitors (their convex
+ * hull), as sjvair.com's map computed area: `@turf/area`, then `convertArea`. 0 for fewer than 3
+ * points not on one line.
+ */
+export function clusterAreaSqMiles(points) {
+    const hull = convexHull(points);
+    if (hull.length < 3)
+        return 0;
+    return convertArea(area(polygon([[...hull, hull[0]]])), "meters", "miles");
+}

package/dist/presets/collocation-sites.d.ts

@@ -0,0 +1,18 @@
+import type { MapPlugin } from "../core/plugin.js";
+import type { CollocationFeatureProperties, DataSource } from "../data/types.js";
+export declare const COLLOCATION_CROSSHAIR_COLOR = "#4A5FC6";
+export interface CollocationSitesPluginOptions {
+    /** Default "collocation-sites". */
+    id?: string;
+    /** Usually `createCollocationSitesStore(…).dataSource`. */
+    source: DataSource<CollocationFeatureProperties>;
+    /** Already-translated layer name for the list and summary. */
+    layerLabel: string;
+}
+/**
+ * Collocation sites as on today's live map: the reference monitor's marker in a crosshair, with
+ * a tooltip of the reference and collocated monitors' readings side by side. Register it before
+ * `monitorsPlugin` so it draws under the monitors; its tooltip still wins the hover. Not
+ * selectable.
+ */
+export declare function collocationSitesPlugin(options: CollocationSitesPluginOptions): MapPlugin;

package/dist/presets/collocation-sites.js

@@ -0,0 +1,67 @@
+import { CROSSHAIR_ICON_SIZE, withCrosshair } from "../plugins/icons.js";
+import { pointsPlugin } from "../plugins/points.svelte.js";
+import CollocationTooltip from "./CollocationTooltip.svelte";
+import { componentSnippet, intervalLookup, MONITOR_INACTIVE_COLOR, MONITOR_INSIDE_OUTLINE, monitorShape, SHAPES } from "./monitors.js";
+// Ported from monitor-map 4.3 (src/lib/collocation-sites/): each site drawn at its reference
+// monitor, in that monitor's shape and level color, wrapped in a crosshair.
+// The user's decision (2026-11-04), an exception to the theme-token rule: the crosshair is this
+// blue on every map and theme, as on sjvair.com.
+export const COLLOCATION_CROSSHAIR_COLOR = "#4A5FC6";
+const BORDER_WIDTH = 2;
+/** `shape:location`, e.g. "triangle:inside", as the monitors preset's icons. */
+function category(props) {
+    return `${monitorShape(props.type)}:${props.location === "inside" ? "inside" : "outside"}`;
+}
+/**
+ * Collocation sites as on today's live map: the reference monitor's marker in a crosshair, with
+ * a tooltip of the reference and collocated monitors' readings side by side. Register it before
+ * `monitorsPlugin` so it draws under the monitors; its tooltip still wins the hover. Not
+ * selectable.
+ */
+export function collocationSitesPlugin(options) {
+    const intervalFor = intervalLookup();
+    const plugin = pointsPlugin({
+        id: options.id ?? "collocation-sites",
+        source: options.source,
+        layerLabel: options.layerLabel,
+        selectable: false,
+        icon: {
+            category,
+            draw(cat, color) {
+                const [shape, location] = cat.split(":");
+                const marker = SHAPES[shape](color, BORDER_WIDTH, location === "inside" ? MONITOR_INSIDE_OUTLINE : undefined);
+                return withCrosshair(marker, COLLOCATION_CROSSHAIR_COLOR);
+            },
+            size: CROSSHAIR_ICON_SIZE,
+            muted: (props) => !props.isActive,
+            mutedColor: MONITOR_INACTIVE_COLOR
+        },
+        tooltipShowsName: true,
+        tooltip: (_item, props, env) => componentSnippet(CollocationTooltip, {
+            site: props,
+            scale: env.scale,
+            messages: env.messages,
+            format: env.format,
+            referenceInterval: null,
+            colocatedInterval: null
+        }, Promise.all([
+            intervalFor(props.type, env.metadata),
+            props.colocatedType
+                ? intervalFor(props.colocatedType, env.metadata)
+                : Promise.resolve(null)
+        ]).then(([referenceInterval, colocatedInterval]) => ({
+            referenceInterval,
+            colocatedInterval
+        })))
+    });
+    // monitor-map registers the collocation tooltip at the highest priority, over the monitors.
+    plugin.hoverPriority = Number.MAX_SAFE_INTEGER;
+    // The sites use the monitors' scale, which the monitors' own section shows; only a loading
+    // or failure status still reports here.
+    const legend = plugin.legend;
+    plugin.legend = () => {
+        const data = legend?.() ?? null;
+        return data && "scale" in data ? null : data;
+    };
+    return plugin;
+}

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

@@ -0,0 +1,26 @@
+export interface FireGroup {
+    id: string;
+    /** Mean [lng, lat] of the group's fires. */
+    coordinates: [number, number];
+    /** Mean fire radiative power of the group's fires. */
+    avgFrp: number;
+    count: number;
+}
+export interface FireDetection {
+    id: string;
+    coordinates: [number, number];
+    /** Fire radiative power; a fire without a finite one is skipped. */
+    frp: number | null;
+    /** ISO 8601. Of several fires at the same coordinates, the latest is kept (else the first). */
+    timestamp?: string;
+}
+/**
+ * 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 declare function cleanFires<F extends FireDetection>(fires: F[]): F[];
+/**
+ * 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 declare function groupFires(fires: FireDetection[]): FireGroup[];

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,30 @@
+import type { MapPlugin } from "../core/plugin.js";
+import type { DataSource, FireFeatureProperties } from "../data/types.js";
+export interface HmsFirePluginOptions {
+    /** Default "hms-fire". */
+    id?: string;
+    /**
+     * The fires, or with `hotspots` the groups shown below zoom 10 (listed). A feature with a
+     * `count` is a group (its tooltip says "Average" from 2 detections); one without is a single
+     * detection.
+     */
+    source: DataSource<FireFeatureProperties>;
+    /** Single detections shown from zoom 10 instead of `source` (not listed). Default: none. */
+    hotspots?: DataSource<FireFeatureProperties>;
+    /** 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: the power in a
+ * reading box colored by its level, beside the name and level; only the groups are listed. Values
+ * are cut off at the display precision, not rounded, in the tooltip, list, and accessible names.
+ *
+ * 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,86 @@
+import { scopedContext } from "../core/scoped-context.js";
+import { fireIcon } from "../plugins/icons.js";
+import { pointsPlugin } from "../plugins/points.svelte.js";
+import FireTooltip from "./FireTooltip.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",
+        truncateValues: true,
+        tooltipShowsName: true,
+        tooltip: (item, props, env) => componentSnippet(FireTooltip, {
+            item,
+            count: typeof props.count === "number" ? props.count : null,
+            messages: env.messages,
+            format: env.format
+        }),
+        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: the power in a
+ * reading box colored by its level, beside the name and level; only the groups are listed. Values
+ * are cut off at the display precision, not rounded, in the tooltip, list, and accessible names.
+ *
+ * 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 });
+    return {
+        id,
+        label: layerLabel,
+        get dataset() {
+            return groups.dataset;
+        },
+        selectable: false,
+        setup(ctx) {
+            const teardownGroups = groups.setup(scopedContext(ctx, "groups:"));
+            const teardownSingles = singles.setup(scopedContext(ctx, "hotspots:"));
+            return () => {
+                teardownSingles();
+                teardownGroups();
+            };
+        },
+        legend: groups.legend,
+        // Only the groups are listed; a hovered hotspot shows the same box as a group.
+        features: groups.features,
+        tooltip: groups.tooltip,
+        tooltipShowsName: true,
+        hoverTooltip(hit) {
+            const item = singles.features?.().find((f) => f.refKey === hit.refKey);
+            return item && singles.tooltip?.(item);
+        }
+    };
+}

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

@@ -0,0 +1,20 @@
+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. Hovering a plume shows no tooltip and never hides another
+ * layer's (`hoverable: false`); focusing one from the list still pins its tooltip.
+ *
+ * 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,22 @@
+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. Hovering a plume shows no tooltip and never hides another
+ * layer's (`hoverable: false`); focusing one from the list still pins its tooltip.
+ *
+ * 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",
+        hoverable: false
+    });
+}

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;