@sjvair/monitor-map 4.2.0 → 4.3.0

package/README.md

@@ -106,6 +106,20 @@ parameter: the panel shows the map's pollutant when the monitor reports it and o
 one it does report, saying so. An inactive monitor gets a panel with its past data and a
 note that it has no current readings; an unknown id gets "Monitor not found."
 
+### Cancelling requests
+
+`monitorsManager.init()` and `update()`, `collocationSitesManager.init()` and `update()`,
+`hmsManager.init()`, `loadSmoke()` and `loadFire()`, and `evStationsManager.loadLvl2Stations()`
+and `loadLvl3Stations()` take `{ signal }` (an `AbortSignal`). Aborting rejects that call with
+the signal's reason (a call that is a no-op, such as `update()` before init or `init()` once
+initialized, resolves as before). The panel, chart and subscription status cancel their own superseded
+requests when the selection changes; that work resolves quietly. A `monitorsManager.init()`
+run is shared: aborting your signal stops only your wait, and the run itself is cancelled only
+when every caller waiting on it has aborted.
+
+A host that depends on `@sjvair/sdk` directly must use `^4.7.0`, so npm installs one copy. A
+nested copy ignores the host's `setOrigin`.
+
 ### Embedding `MapShell` directly, with a reduced integration set
 
 `MonitorMapLayout` is an opinionated wrapper around the lower-level `MapShell`

package/dist/lib/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>;

package/dist/lib/abort.js

@@ -0,0 +1,51 @@
+/**
+ * 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 function anySignal(...signals) {
+    const controller = new AbortController();
+    const cleanups = [];
+    const dispose = () => {
+        for (const cleanup of cleanups.splice(0))
+            cleanup();
+    };
+    for (const input of signals) {
+        if (!input)
+            continue;
+        if (input.aborted) {
+            controller.abort(input.reason);
+            dispose();
+            break;
+        }
+        const onAbort = () => {
+            controller.abort(input.reason);
+            dispose();
+        };
+        input.addEventListener("abort", onAbort, { once: true });
+        cleanups.push(() => input.removeEventListener("abort", onAbort));
+    }
+    return { signal: controller.signal, dispose };
+}
+/**
+ * Settles like `promise`, unless `signal` aborts first, in which case it rejects with
+ * `signal.reason`. The inner promise's later outcome is swallowed.
+ */
+export function untilAborted(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted) {
+        promise.catch(() => { });
+        return Promise.reject(signal.reason);
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason);
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(error);
+        });
+    });
+}

package/dist/lib/collocation-sites/collocations.svelte.d.ts

@@ -1,9 +1,10 @@
 import { type CollocationSite } from "@sjvair/sdk";
+import type { SignalOptions } from "../abort";
 declare class CollocationSitesManager {
     initialized: boolean;
     collocationSites: Array<CollocationSite> | null;
-    init(): Promise<void>;
-    update(): Promise<void>;
+    init({ signal }?: SignalOptions): Promise<void>;
+    update({ signal }?: SignalOptions): Promise<void>;
 }
 export declare const collocationSitesManager: CollocationSitesManager;
 export type { CollocationSitesManager };

package/dist/lib/collocation-sites/collocations.svelte.js

@@ -2,16 +2,20 @@ import { getCollocationSites } from "@sjvair/sdk";
 class CollocationSitesManager {
     initialized = $state(false);
     collocationSites = $state(null);
-    async init() {
+    async init({ signal } = {}) {
         if (this.initialized)
             return;
-        this.collocationSites = await getCollocationSites();
+        if (signal?.aborted)
+            throw signal.reason;
+        this.collocationSites = await getCollocationSites({ signal });
         this.initialized = true;
     }
-    async update() {
+    async update({ signal } = {}) {
         if (!this.initialized)
             return;
-        this.collocationSites = await getCollocationSites();
+        if (signal?.aborted)
+            throw signal.reason;
+        this.collocationSites = await getCollocationSites({ signal });
     }
 }
 export const collocationSitesManager = new CollocationSitesManager();

package/dist/lib/data-chart/DataChart.svelte

@@ -143,12 +143,27 @@
 	};
 
 	let chartRequest = 0;
+	let chartController: AbortController | undefined;
+
+	// A closed panel cancels its in-flight fetch.
+	$effect(() => () => chartController?.abort());
 
 	// `silent` keeps the current chart on screen while a timed refresh loads.
 	async function loadChartData({ silent = false } = {}) {
 		const request = ++chartRequest;
+		chartController?.abort();
+		const controller = (chartController = new AbortController());
 		if (!silent) chartManager.loading = true;
-		const data = await fetchChartData(monitor, chartManager.dateRange, pollutant);
+		let data: Awaited<ReturnType<typeof fetchChartData>>;
+		try {
+			data = await fetchChartData(monitor, chartManager.dateRange, pollutant, {
+				signal: controller.signal
+			});
+		} catch (err) {
+			// Superseded or closed: the newer call owns `loading` and the chart, so leave both.
+			if (controller.signal.aborted) return;
+			throw err;
+		}
 		// A newer request (another range, monitor, pollutant or refresh) owns the chart now.
 		if (request !== chartRequest) return;
 		// A failed request resolves to [] (an empty range is [[], []]); a background refresh

package/dist/lib/data-chart/requests.d.ts

@@ -1,6 +1,7 @@
 import { type MonitorDetails } from "@sjvair/sdk";
 import type { PanelPollutant } from "../monitors/panel-pollutant";
 import type { DateRange } from "./DateRange";
+import type { SignalOptions } from "../abort";
 /** The monitor fields the chart reads. */
 export type ChartMonitor = Pick<MonitorDetails, "id" | "name" | "type" | "data_source">;
-export declare function fetchChartData(m: ChartMonitor, d: DateRange, entryType: PanelPollutant): Promise<uPlot.AlignedData>;
+export declare function fetchChartData(m: ChartMonitor, d: DateRange, entryType: PanelPollutant, options?: SignalOptions): Promise<uPlot.AlignedData>;

package/dist/lib/data-chart/requests.js

@@ -1,12 +1,12 @@
 import { getMonitorEntries } from "@sjvair/sdk";
 import { getUnixTime, parseISO, differenceInMinutes, addMinutes } from "date-fns";
-export async function fetchChartData(m, d, entryType) {
+export async function fetchChartData(m, d, entryType, options = {}) {
     return await getMonitorEntries({
         entryType,
         monitorId: m.id,
         timestampGte: d.start,
         timestampLte: d.end
-    })
+    }, { signal: options.signal })
         .then((entries) => {
         const xAxisData = [];
         const updateDuration = m.data_source.name === "PurpleAir" ? 2 : 60;
@@ -26,6 +26,9 @@ export async function fetchChartData(m, d, entryType) {
         return [xAxisData.map((d) => getUnixTime(d)), yAxisRecord];
     })
         .catch((err) => {
+        // A cancelled request is not a failure: let the caller see the reason, log nothing.
+        if (options.signal?.aborted)
+            throw options.signal.reason;
         console.error("Failed to load chart data: ", err);
         return [];
     });

package/dist/lib/ev-stations/ev-stations.svelte.d.ts

@@ -1,9 +1,10 @@
+import type { SignalOptions } from "../abort";
 import type { EvStation } from "./types";
 declare class EvStationsManager {
     lvl2Stations: Array<EvStation> | undefined;
     lvl3Stations: Array<EvStation> | undefined;
-    loadLvl3Stations(): Promise<void>;
-    loadLvl2Stations(): Promise<void>;
+    loadLvl3Stations({ signal }?: SignalOptions): Promise<void>;
+    loadLvl2Stations({ signal }?: SignalOptions): Promise<void>;
 }
 export declare const evStationsManager: EvStationsManager;
 export type { EvStationsManager };

package/dist/lib/ev-stations/ev-stations.svelte.js

@@ -3,17 +3,19 @@ import * as ZipCodes from "./zip-codes";
 class EvStationsManager {
     lvl2Stations = $state();
     lvl3Stations = $state();
-    async loadLvl3Stations() {
-        this.lvl3Stations = await fetchEvStations("dc_fast");
+    async loadLvl3Stations({ signal } = {}) {
+        this.lvl3Stations = await fetchEvStations("dc_fast", signal);
     }
-    async loadLvl2Stations() {
-        this.lvl2Stations = await fetchEvStations("2");
+    async loadLvl2Stations({ signal } = {}) {
+        this.lvl2Stations = await fetchEvStations("2", signal);
     }
 }
 const zipCodes = Object.values(ZipCodes)
     .reduce((prev, curr) => prev.concat(curr))
     .join(",");
-async function fetchEvStations(chargingLevel) {
+async function fetchEvStations(chargingLevel, signal) {
+    if (signal?.aborted)
+        throw signal.reason;
     const url = new URL(`https://developer.nlr.gov/api/alt-fuel-stations/v1.json`);
     url.searchParams.set("fuel_type", "ELEC");
     url.searchParams.set("state", "CA");
@@ -22,7 +24,7 @@ async function fetchEvStations(chargingLevel) {
     url.searchParams.set("ev_charging_level", chargingLevel);
     url.searchParams.set("zip", zipCodes);
     url.searchParams.set("api_key", import.meta.env.VITE_NREL_KEY);
-    return await fetch(url)
+    return await fetch(url, { signal })
         .then(async (res) => await res.json())
         .then((data) => {
         const fuelStations = data.fuel_stations;

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

@@ -1,4 +1,5 @@
 import { type HMSFireGeoJSON, type HMSSmokeGeoJSON } from "@sjvair/sdk/hms";
+import type { SignalOptions } from "../abort";
 export interface HMSFireGroup {
     id: string;
     coordinates: [number, number];
@@ -11,9 +12,9 @@ declare class HmsManager {
         frp: number;
     }> | undefined;
     fireGroups: Array<HMSFireGroup> | undefined;
-    init(): Promise<void>;
-    loadSmoke(): Promise<void>;
-    loadFire(): Promise<void>;
+    init({ signal }?: SignalOptions): Promise<void>;
+    loadSmoke({ signal }?: SignalOptions): Promise<void>;
+    loadFire({ signal }?: SignalOptions): Promise<void>;
 }
 export declare const hmsManager: HmsManager;
 export type { HmsManager as HMSManager };

package/dist/lib/hms/hms.svelte.js

@@ -7,21 +7,31 @@ class HmsManager {
     smoke = $state();
     fire = $state();
     fireGroups = $state();
-    async init() {
-        await Promise.allSettled([this.loadSmoke(), this.loadFire()]);
+    async init({ signal } = {}) {
+        if (signal?.aborted)
+            throw signal.reason;
+        await Promise.allSettled([this.loadSmoke({ signal }), this.loadFire({ signal })]);
+        if (signal?.aborted)
+            throw signal.reason;
     }
-    async loadSmoke() {
-        this.smoke = await getHMSSmoke();
+    async loadSmoke({ signal } = {}) {
+        if (signal?.aborted)
+            throw signal.reason;
+        this.smoke = await getHMSSmoke({ signal });
     }
-    async loadFire() {
+    async loadFire({ signal } = {}) {
         try {
-            const raw = await getHMSFire();
+            if (signal?.aborted)
+                throw signal.reason;
+            const raw = await getHMSFire({ signal });
             const filtered = raw.filter((d) => d.frp !== null);
             const deduped = deduplicateByCoordinates(filtered);
             this.fire = deduped;
             this.fireGroups = computeFireGroups(deduped);
         }
         catch (err) {
+            if (signal?.aborted)
+                throw err;
             console.error("HMS fire load failed:", err);
         }
     }

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.js

@@ -9,13 +9,15 @@ export class MonitorDetailsState {
     #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);
+            const monitor = await getMonitorDetails(id, { signal });
             if (request !== this.#request)
                 return;
             this.monitor = monitor;
@@ -37,17 +39,23 @@ export class MonitorDetailsState {
         if (this.status !== "ready" || this.#id === null)
             return;
         const request = ++this.#request;
+        const { signal } = this.#restart();
         try {
-            const monitor = await getMonitorDetails(this.#id);
+            const monitor = await getMonitorDetails(this.#id, { signal });
             if (request !== this.#request)
                 return;
             this.monitor = monitor;
         }
         catch (error) {
-            if (request === this.#request)
+            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);
     }

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

@@ -1,6 +1,7 @@
 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 {
     /**
@@ -8,6 +9,13 @@ export interface MonitorsInitOptions {
      * 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;
@@ -33,7 +41,12 @@ declare class MonitorsManager implements MonitorsDataSource {
      * 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,9 +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
@@ -44,23 +46,67 @@ class MonitorsManager {
     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;
-            this.#requestedAutoUpdate = false;
-        });
-        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;
+    }
+    /**
+     * 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() {
+    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;
@@ -68,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]);
@@ -80,10 +126,13 @@ 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;
         if (this.#requestedAutoUpdate)
@@ -101,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/subscriptions.d.ts

@@ -0,0 +1,3 @@
+import type { SignalOptions } from "../abort";
+export declare function getApiToken(): string | undefined;
+export declare function loadSubscriptionLevel(monitorId: string, options?: SignalOptions): Promise<string | null>;