@sjvair/monitor-map 4.1.0 → 4.3.0

package/dist/lib/map/integrations/map-geojson-integration.svelte.d.ts

@@ -15,5 +15,18 @@ export declare abstract class MapGeoJSONIntegration<T = Record<string, unknown>>
 }
 export declare abstract class MapIconLayerIntegration<T = Record<string, unknown>> extends MapGeoJSONIntegration<T> {
     abstract icons: MapIconManager;
+    private generation;
+    /**
+     * Drops every callback still waiting on icons. `apply()` and `remove()` call it, so a
+     * subclass overriding `apply()` without calling `super.apply()` first must call it itself.
+     */
+    protected supersedePending(): void;
+    /**
+     * Runs `run` once the icons have loaded, unless an `apply()` or `remove()` has happened
+     * since (the state it was scheduled for is gone) or a basemap change is in flight (the
+     * refresh on "style.load" re-applies).
+     */
+    protected whenIconsLoad(run: () => void): void;
     apply(): void;
+    remove(): void;
 }

package/dist/lib/map/integrations/map-geojson-integration.svelte.js

@@ -19,16 +19,42 @@ export class MapGeoJSONIntegration extends MapLayerIntegration {
     }
 }
 export class MapIconLayerIntegration extends MapGeoJSONIntegration {
+    generation = 0;
+    /**
+     * Drops every callback still waiting on icons. `apply()` and `remove()` call it, so a
+     * subclass overriding `apply()` without calling `super.apply()` first must call it itself.
+     */
+    supersedePending() {
+        this.generation++;
+    }
+    /**
+     * Runs `run` once the icons have loaded, unless an `apply()` or `remove()` has happened
+     * since (the state it was scheduled for is gone) or a basemap change is in flight (the
+     * refresh on "style.load" re-applies).
+     */
+    whenIconsLoad(run) {
+        const generation = this.generation;
+        this.icons
+            .loadIcons()
+            .then(() => {
+            if (generation !== this.generation || mapManager.styleLoading)
+                return;
+            run();
+        })
+            .catch(console.error);
+    }
     apply() {
         if (!mapManager.map)
             return;
-        this.icons.loadIcons().then(() => {
-            // A basemap change started while icons loaded; the refresh on "style.load" re-applies.
-            if (mapManager.styleLoading)
-                return;
+        this.supersedePending();
+        this.whenIconsLoad(() => {
             this.removeLayerAndSource();
             mapManager.map?.addSource(this.referenceId, this.mapSource);
             super.apply();
         });
     }
+    remove() {
+        this.supersedePending();
+        super.remove();
+    }
 }

package/dist/lib/map/map-style-state.svelte.d.ts

@@ -4,10 +4,20 @@ declare class MapStyleState {
     referenceStyle: ReferenceMapStyle;
     variant: MapStyleVariant;
     private applied;
+    private loaded;
+    private stopWaiting;
     selectReferenceStyle(style: ReferenceMapStyle): void;
     selectVariant(variant: MapStyleVariant): void;
     reset(): void;
     private apply;
+    private load;
+    /**
+     * A style that fails to load leaves the map with no style at all, so go back to the last one
+     * that loaded and make the selection say so. When that one fails too (e.g. offline) there is
+     * nothing to draw on: `styleLoading` stays set, since integrations cannot add layers to a
+     * missing style, and the next selection starts a fresh attempt.
+     */
+    private recover;
 }
 export declare const mapStyleState: MapStyleState;
 export type { MapStyleState };

package/dist/lib/map/map-style-state.svelte.js

@@ -5,7 +5,12 @@ import { variantForStyle } from "./basemap";
 class MapStyleState {
     referenceStyle = $state.raw(DefaultMapStyle.getReferenceStyle());
     variant = $state.raw(DefaultMapStyle);
+    // The variant last handed to setStyle (loaded or still loading); null once a load has failed
+    // with nothing left to fall back to, so that any later selection is tried again.
     applied = DefaultMapStyle;
+    // The variant the map last finished loading, which a failed change falls back to.
+    loaded = DefaultMapStyle;
+    stopWaiting = null;
     selectReferenceStyle(style) {
         this.referenceStyle = style;
         this.selectVariant(variantForStyle(style, this.variant));
@@ -19,17 +24,63 @@ class MapStyleState {
         this.selectVariant(DefaultMapStyle);
     }
     apply() {
+        if (!mapManager.map || this.variant === this.applied)
+            return;
+        this.load(this.variant);
+    }
+    load(variant) {
         const map = mapManager.map;
-        if (!map || this.variant === this.applied)
+        if (!map)
             return;
-        this.applied = this.variant;
+        // A newer change supersedes one still in flight.
+        this.stopWaiting?.();
+        this.applied = variant;
         // setStyle wipes every custom source/layer; re-add enabled integrations once it loads.
-        map.once("style.load", () => {
+        const onLoad = () => {
+            this.stopWaiting?.();
+            this.loaded = variant;
             mapManager.styleLoading = false;
             integrationsManager.refresh();
-        });
+        };
+        // "error" also fires for tiles, sprites and glyphs; only the style document failing means
+        // the change failed.
+        const onError = (event) => {
+            if (!isRequestFor(event.error, variant.getExpandedStyleURL()))
+                return;
+            this.stopWaiting?.();
+            this.recover(variant);
+        };
+        this.stopWaiting = () => {
+            map.off("style.load", onLoad);
+            map.off("error", onError);
+            this.stopWaiting = null;
+        };
+        map.on("style.load", onLoad);
+        map.on("error", onError);
         mapManager.styleLoading = true;
-        map.setStyle(this.variant);
+        map.setStyle(variant);
     }
+    /**
+     * A style that fails to load leaves the map with no style at all, so go back to the last one
+     * that loaded and make the selection say so. When that one fails too (e.g. offline) there is
+     * nothing to draw on: `styleLoading` stays set, since integrations cannot add layers to a
+     * missing style, and the next selection starts a fresh attempt.
+     */
+    recover(failed) {
+        if (failed === this.loaded) {
+            this.applied = null;
+            return;
+        }
+        this.variant = this.loaded;
+        this.referenceStyle = this.loaded.getReferenceStyle();
+        this.load(this.loaded);
+    }
+}
+/** Whether a map "error" event's error is a failed request for `url`, ignoring the query. */
+function isRequestFor(error, url) {
+    const failed = error?.url;
+    if (typeof failed !== "string")
+        return false;
+    return failed.split("?")[0] === url.split("?")[0];
 }
 export const mapStyleState = new MapStyleState();

package/dist/lib/monitors/components/MonitorSubscriptionManager.svelte

@@ -1,7 +1,8 @@
 <script lang="ts">
 	import { BellCheckIcon, BellOffIcon, ChevronDownIcon } from "@lucide/svelte";
-	import { getSubscriptions, subscribe, unsubscribe } from "@sjvair/sdk/account";
+	import { subscribe, unsubscribe } from "@sjvair/sdk/account";
 	import { monitorsManager } from "../..";
+	import { getApiToken, loadSubscriptionLevel } from "../subscriptions";
 
 	interface MonitorSubscriptionManagerProps {
 		monitorId: string;
@@ -35,24 +36,24 @@
 	});
 
 	$effect(() => {
-		void monitorId;
+		const id = monitorId;
 		open = false;
 		subscribedLevel = null;
-		loadSubscription();
-	});
-
-	async function loadSubscription() {
-		const id = monitorId;
+		const controller = new AbortController();
+		const { signal } = controller;
 		loading = true;
-		try {
-			const subscriptions = await getSubscriptions(getApiToken());
-			if (id !== monitorId) return;
-			const match = subscriptions.find((s) => s.monitor === id);
-			subscribedLevel = match?.level ?? null;
-		} finally {
-			if (id === monitorId) loading = false;
-		}
-	}
+		loadSubscriptionLevel(id, { signal })
+			.then((level) => {
+				if (!signal.aborted) subscribedLevel = level;
+			})
+			.catch((error) => {
+				if (!signal.aborted) throw error;
+			})
+			.finally(() => {
+				if (!signal.aborted) loading = false;
+			});
+		return () => controller.abort();
+	});
 
 	async function handleLevelClick(level: string | null) {
 		if (saving || !level) return;
@@ -75,12 +76,6 @@
 		}
 		open = false;
 	}
-
-	function getApiToken(): string {
-		return (
-			(globalThis as unknown as Record<string, Record<string, string>>)["USER"]?.api_token ?? ""
-		);
-	}
 </script>
 
 <div class="relative select-none">

package/dist/lib/monitors/monitor-details.svelte.d.ts

@@ -0,0 +1,15 @@
+import { type MonitorDetails } from "@sjvair/sdk";
+export type MonitorDetailsStatus = "loading" | "ready" | "not-found" | "failed";
+/**
+ * One monitor, fetched by id. Unlike `monitorsManager.latest`, this does not depend on the
+ * map's pollutant or on the monitor being active, so the detail panel can show any monitor.
+ */
+export declare class MonitorDetailsState {
+    #private;
+    monitor: MonitorDetails | null;
+    status: MonitorDetailsStatus;
+    load(id: string): Promise<void>;
+    /** Re-fetches the monitor already shown. A failure keeps the data on screen. */
+    refresh(): Promise<void>;
+    retry(): Promise<void>;
+}

package/dist/lib/monitors/monitor-details.svelte.js

@@ -0,0 +1,71 @@
+import { getMonitorDetails } from "@sjvair/sdk";
+/**
+ * One monitor, fetched by id. Unlike `monitorsManager.latest`, this does not depend on the
+ * map's pollutant or on the monitor being active, so the detail panel can show any monitor.
+ */
+export class MonitorDetailsState {
+    monitor = $state.raw(null);
+    status = $state("loading");
+    #id = null;
+    // Bumped per request; a response for anything but the latest request is dropped.
+    #request = 0;
+    #controller = null;
+    async load(id) {
+        this.#id = id;
+        const request = ++this.#request;
+        const { signal } = this.#restart();
+        this.monitor = null;
+        this.status = "loading";
+        try {
+            const monitor = await getMonitorDetails(id, { signal });
+            if (request !== this.#request)
+                return;
+            this.monitor = monitor;
+            this.status = "ready";
+        }
+        catch (error) {
+            if (request !== this.#request)
+                return;
+            if (isNotFound(error)) {
+                this.status = "not-found";
+                return;
+            }
+            console.error(error);
+            this.status = "failed";
+        }
+    }
+    /** Re-fetches the monitor already shown. A failure keeps the data on screen. */
+    async refresh() {
+        if (this.status !== "ready" || this.#id === null)
+            return;
+        const request = ++this.#request;
+        const { signal } = this.#restart();
+        try {
+            const monitor = await getMonitorDetails(this.#id, { signal });
+            if (request !== this.#request)
+                return;
+            this.monitor = monitor;
+        }
+        catch (error) {
+            if (!signal.aborted && request === this.#request)
+                console.error(error);
+        }
+    }
+    /** Aborts whatever request is in flight and starts a new controller for the next one. */
+    #restart() {
+        this.#controller?.abort();
+        return (this.#controller = new AbortController());
+    }
+    retry() {
+        return this.#id === null ? Promise.resolve() : this.load(this.#id);
+    }
+}
+/**
+ * The SDK rejects a failed request with `cause.result.status` set to the HTTP status, or,
+ * when it could not parse the error body, with the `Response` itself as the cause.
+ */
+function isNotFound(error) {
+    const cause = error
+        ?.cause;
+    return cause?.result?.status === 404 || cause?.status === 404;
+}

package/dist/lib/monitors/monitors-map-integration.svelte.js

@@ -257,9 +257,9 @@ class MonitorsMapIntegration extends MapIconLayerIntegration {
             clickManager.unregister([this.referenceId]);
             this.tooltipManager.disable();
             this.renderer.remove();
-            this.icons.loadIcons().then(() => {
-                if (mapManager.styleLoading)
-                    return;
+            // Clustering may be toggled again before the icons arrive; only the latest apply runs.
+            this.supersedePending();
+            this.whenIconsLoad(() => {
                 this.renderer.apply(this.handleMonitorClick);
                 this.tooltipManager.enable();
                 this.applySelectedState();
@@ -271,9 +271,7 @@ class MonitorsMapIntegration extends MapIconLayerIntegration {
             this.tooltipManager.enable();
             clickManager.unregister([this.referenceId]);
             super.apply();
-            this.icons.loadIcons().then(() => {
-                if (mapManager.styleLoading)
-                    return;
+            this.whenIconsLoad(() => {
                 clickManager.register([this.referenceId], this.handleMonitorClick);
                 this.applySelectedState();
             });

package/dist/lib/monitors/monitors.svelte.d.ts

@@ -1,7 +1,22 @@
 import { type MonitorData, type MonitorLatestType, type MonitorsMeta, type SJVAirEntryLevel } from "@sjvair/sdk";
 import { XMap } from "@tstk/builtin-extensions";
 import { Interval } from "@tstk/utils";
+import { type SignalOptions } from "../abort";
 import type { MonitorsDataSource } from "./types";
+export interface MonitorsInitOptions {
+    /**
+     * Start the 2-minute polling once the initial load finishes. Defaults to true; pass false to
+     * load the data without showing a map (`resumeAutoUpdate()` starts polling later).
+     */
+    autoUpdate?: boolean;
+    /**
+     * Stops waiting: the returned promise rejects with the signal's reason. The shared run keeps
+     * going for the other calls waiting on it, and is cancelled only when every call waiting on it
+     * passed a signal and all of those aborted. An aborted call's pollutant and `autoUpdate` stay
+     * recorded. Ignored once initialized.
+     */
+    signal?: AbortSignal;
+}
 declare class MonitorsManager implements MonitorsDataSource {
     #private;
     autoUpdate: Interval;
@@ -15,15 +30,23 @@ declare class MonitorsManager implements MonitorsDataSource {
     /**
      * Safe to call from several places: overlapping calls share one run, and a failed run can
      * be retried. An explicit "pm25"/"o3" wins over a call without one, whichever came first;
-     * between two explicit values the most recent wins.
+     * between two explicit values the most recent wins. Polling starts when the run finishes
+     * unless every call sharing it passed `autoUpdate: false`. A no-op once initialized, so it
+     * never restarts polling either: that is `resumeAutoUpdate()`.
      */
-    init(urlPollutant?: string | number | boolean): Promise<void>;
+    init(urlPollutant?: string | number | boolean, options?: MonitorsInitOptions): Promise<void>;
     /**
-     * Restarts polling after something stopped it (MonitorMapLayout stops it on destroy),
-     * refreshing first since the data may be stale. A no-op before init or while polling.
+     * Starts polling when it is not running: after something stopped it (MonitorMapLayout stops
+     * it on destroy) or after an init that opted out of it. Refreshes first since the data may
+     * be stale. A no-op before init or while polling.
      */
     resumeAutoUpdate(): void;
-    update(): Promise<void>;
+    /**
+     * Refreshes the list and the latest readings. Starting an update aborts the previous
+     * in-flight one, which then resolves without touching state. Pass `signal` to cancel from the
+     * outside: that rejects with the signal's reason.
+     */
+    update(options?: SignalOptions): Promise<void>;
 }
 export declare const monitorsManager: MonitorsManager;
 export type { MonitorsManager };

package/dist/lib/monitors/monitors.svelte.js

@@ -2,6 +2,7 @@ import { getMonitors, getMonitorsList, getMonitorsMeta } from "@sjvair/sdk";
 import { XMap } from "@tstk/builtin-extensions";
 import { Interval } from "@tstk/utils";
 import { untrack } from "svelte";
+import { anySignal, untilAborted } from "../abort";
 class MonitorsManager {
     autoUpdate = new Interval(async () => await this.update(), 2 * 60 * 1000);
     initialized = $state(false);
@@ -10,8 +11,10 @@ class MonitorsManager {
     meta = $state(null);
     pollutant = $state(null);
     levels = $derived(this.meta?.entryType(this.pollutant ?? this.meta.default_pollutant).asIter.levels || null);
-    #initPromise = null;
+    #initRun = null;
     #requestedPollutant = null;
+    #requestedAutoUpdate = false;
+    #updateController = null;
     constructor() {
         // Refetch monitors when the pollutant changes after the initial load, wherever the change
         // comes from (Pollutant menu, URL sync, a host's own UI). Clearing first blanks the markers
@@ -36,25 +39,74 @@ class MonitorsManager {
     /**
      * Safe to call from several places: overlapping calls share one run, and a failed run can
      * be retried. An explicit "pm25"/"o3" wins over a call without one, whichever came first;
-     * between two explicit values the most recent wins.
+     * between two explicit values the most recent wins. Polling starts when the run finishes
+     * unless every call sharing it passed `autoUpdate: false`. A no-op once initialized, so it
+     * never restarts polling either: that is `resumeAutoUpdate()`.
      */
-    init(urlPollutant) {
+    init(urlPollutant, options = {}) {
         if (this.initialized)
             return Promise.resolve();
+        const { signal } = options;
+        // Nothing is recorded or started for a call that is already cancelled.
+        if (signal?.aborted)
+            return Promise.reject(signal.reason);
+        if (options.autoUpdate !== false)
+            this.#requestedAutoUpdate = true;
         if (urlPollutant === "pm25" || urlPollutant === "o3") {
             this.#requestedPollutant = urlPollutant;
         }
-        this.#initPromise ??= this.#runInit().finally(() => {
-            this.#initPromise = null;
-            this.#requestedPollutant = null;
-        });
-        return this.#initPromise;
+        const run = (this.#initRun ??= this.#startInitRun());
+        if (!signal) {
+            run.unsignalled = true;
+            return run.promise;
+        }
+        run.signalled++;
+        const onAbort = () => {
+            run.aborted++;
+            if (!run.unsignalled && run.aborted === run.signalled)
+                this.#abortInitRun(run);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        const cleanup = () => signal.removeEventListener("abort", onAbort);
+        run.promise.then(cleanup, cleanup);
+        return untilAborted(run.promise, signal);
+    }
+    #startInitRun() {
+        const controller = new AbortController();
+        const run = {
+            promise: this.#runInit(controller.signal).finally(() => {
+                if (this.#initRun === run)
+                    this.#clearInitRun();
+            }),
+            controller,
+            signalled: 0,
+            aborted: 0,
+            unsignalled: false
+        };
+        return run;
     }
-    async #runInit() {
+    /**
+     * Cancels a run nobody is waiting on. It is detached at once, so a call arriving before its
+     * rejection settles starts a fresh run instead of joining the cancelled one.
+     */
+    #abortInitRun(run) {
+        if (this.#initRun !== run)
+            return;
+        this.#clearInitRun();
+        run.controller.abort();
+    }
+    #clearInitRun() {
+        this.#initRun = null;
+        this.#requestedPollutant = null;
+        this.#requestedAutoUpdate = false;
+    }
+    async #runInit(signal) {
         // The pollutant the latest readings were requested for.
         let fetchedPollutant = this.#requestedPollutant;
-        const metaRequest = getMonitorsMeta();
-        const listAndMeta = Promise.all([getMonitorsList(), metaRequest]).then(([list, meta]) => {
+        const metaRequest = getMonitorsMeta({ signal });
+        const listAndMeta = Promise.all([getMonitorsList({ signal }), metaRequest]).then(([list, meta]) => {
+            if (signal.aborted)
+                throw signal.reason;
             this.list = list;
             this.meta = meta;
             return meta;
@@ -62,11 +114,11 @@ class MonitorsManager {
         // The latest readings only need the pollutant, so they never wait for the list. An explicit
         // pollutant may still arrive before meta does, in which case the default is never fetched.
         const latestRequest = fetchedPollutant
-            ? getMonitorsLatestMap(fetchedPollutant)
+            ? getMonitorsLatestMap(fetchedPollutant, signal)
             : metaRequest.then((meta) => {
                 const pollutant = this.#requestedPollutant ?? meta.default_pollutant;
                 fetchedPollutant = pollutant;
-                return getMonitorsLatestMap(pollutant);
+                return getMonitorsLatestMap(pollutant, signal);
             });
         // One Promise.all so a failure in either never leaves the other unhandled.
         const [meta, firstLatest] = await Promise.all([listAndMeta, latestRequest]);
@@ -74,18 +126,23 @@ class MonitorsManager {
         // An explicit pollutant may have arrived while the requests above were in flight.
         let wanted = this.#requestedPollutant ?? meta.default_pollutant;
         while (wanted !== fetchedPollutant) {
-            latest = await getMonitorsLatestMap(wanted);
+            latest = await getMonitorsLatestMap(wanted, signal);
             fetchedPollutant = wanted;
             wanted = this.#requestedPollutant ?? meta.default_pollutant;
         }
+        // Cancelled while a request that ignores the signal was settling: leave state to the next run.
+        if (signal.aborted)
+            throw signal.reason;
         this.pollutant = fetchedPollutant;
         this.latest = latest;
-        this.autoUpdate.start();
+        if (this.#requestedAutoUpdate)
+            this.autoUpdate.start();
         this.initialized = true;
     }
     /**
-     * Restarts polling after something stopped it (MonitorMapLayout stops it on destroy),
-     * refreshing first since the data may be stale. A no-op before init or while polling.
+     * Starts polling when it is not running: after something stopped it (MonitorMapLayout stops
+     * it on destroy) or after an init that opted out of it. Refreshes first since the data may
+     * be stale. A no-op before init or while polling.
      */
     resumeAutoUpdate() {
         if (!this.initialized || this.autoUpdate.isActive)
@@ -93,24 +150,67 @@ class MonitorsManager {
         this.update().catch(console.error);
         this.autoUpdate.start();
     }
-    async update() {
+    /**
+     * Refreshes the list and the latest readings. Starting an update aborts the previous
+     * in-flight one, which then resolves without touching state. Pass `signal` to cancel from the
+     * outside: that rejects with the signal's reason.
+     */
+    async update(options = {}) {
         if (!this.initialized)
             return;
-        const pollutant = this.pollutant;
-        const [list, latest] = await Promise.all([
-            getMonitorsList(),
-            getMonitorsLatestMap(pollutant || this.meta?.default_pollutant || "pm25")
-        ]);
-        // The pollutant changed while this was in flight: these readings belong to the previous
-        // one, and the change has already started its own update.
-        if (this.pollutant !== pollutant)
-            return;
-        this.list = list;
-        this.latest = latest;
+        // Nothing has started yet, so an in-flight update is left alone.
+        if (options.signal?.aborted)
+            throw options.signal.reason;
+        const supersededInFlight = this.#updateController !== null;
+        this.#updateController?.abort();
+        const controller = new AbortController();
+        this.#updateController = controller;
+        const combined = anySignal(controller.signal, options.signal);
+        // The caller cancelled this update. If it is still the latest and it cut off an update that
+        // was in flight, that update's data is lost too, so refresh again without a signal.
+        const callerAborted = (signal) => {
+            if (supersededInFlight && this.#updateController === controller) {
+                this.update().catch(console.error);
+            }
+            return signal.reason;
+        };
+        // Set once callerAborted has run, so the catch below does not run it a second time.
+        let abortedError;
+        try {
+            const pollutant = this.pollutant;
+            const [list, latest] = await Promise.all([
+                getMonitorsList({ signal: combined.signal }),
+                getMonitorsLatestMap(pollutant || this.meta?.default_pollutant || "pm25", combined.signal)
+            ]);
+            // Superseded or cancelled while the requests were settling.
+            if (options.signal?.aborted)
+                throw (abortedError = callerAborted(options.signal));
+            if (controller.signal.aborted)
+                return;
+            // The pollutant changed while this was in flight: these readings belong to the previous
+            // one, and the change has already started its own update.
+            if (this.pollutant !== pollutant)
+                return;
+            this.list = list;
+            this.latest = latest;
+        }
+        catch (error) {
+            // The caller's own abort rejects with its reason. A superseded update resolves quietly.
+            if (options.signal?.aborted)
+                throw error === abortedError ? error : callerAborted(options.signal);
+            if (controller.signal.aborted)
+                return;
+            throw error;
+        }
+        finally {
+            combined.dispose();
+            if (this.#updateController === controller)
+                this.#updateController = null;
+        }
     }
 }
-async function getMonitorsLatestMap(pollutant) {
-    const monitors = await getMonitors(pollutant);
+async function getMonitorsLatestMap(pollutant, signal) {
+    const monitors = await getMonitors(pollutant, undefined, { signal });
     const latest = new XMap();
     for (const monitor of monitors) {
         latest.set(monitor.id, monitor);

package/dist/lib/monitors/panel-pollutant.d.ts

@@ -0,0 +1,37 @@
+/** The pollutants the detail panel can show, in order of preference. */
+export declare const PANEL_POLLUTANTS: readonly ["pm25", "o3"];
+export type PanelPollutant = (typeof PANEL_POLLUTANTS)[number];
+/** The slice of the SDK's `MonitorDetails` this module reads. */
+export interface PanelMonitor {
+    type: string;
+    is_active: boolean;
+    latest: Partial<Record<PanelPollutant, {
+        value?: string;
+    }>>;
+}
+/** The slice of the SDK's `MonitorsMeta` this module reads. */
+export interface PanelMeta {
+    monitors: Record<string, {
+        entries: Record<string, unknown>;
+    } | undefined>;
+}
+export interface PanelPollutantChoice {
+    /** Null when the monitor has no reading and its type publishes neither pollutant. */
+    pollutant: PanelPollutant | null;
+    /** Whether the monitor has a current reading for `pollutant`. */
+    hasReading: boolean;
+}
+/** The panel pollutants this monitor has a current, numeric reading for. */
+export declare function readingPollutants(monitor: Pick<PanelMonitor, "latest">): PanelPollutant[];
+/**
+ * The panel pollutants this monitor type publishes. The API marks each entry type with a
+ * `published` flag the SDK does not type; a type that carries the entry without the flag
+ * counts as publishing it.
+ */
+export declare function publishedPollutants(monitorType: string, meta: PanelMeta): PanelPollutant[];
+/**
+ * The pollutant the detail panel shows: the map's when the monitor has it, otherwise the one
+ * the monitor has. A monitor with no current reading (inactive, or nothing reported) still
+ * gets a pollutant when there is one to chart, so its past data can be browsed.
+ */
+export declare function choosePanelPollutant(mapPollutant: PanelPollutant | null, monitor: PanelMonitor, meta: PanelMeta): PanelPollutantChoice;