@sjvair/monitor-map 4.1.0 → 4.3.0

package/README.md

@@ -47,8 +47,9 @@ export const { route, navigate, p, isActive, Router } = createRouter({
 <Router />
 ```
 
-This is what the sjvair.com widget and `sjvair-mobile` use today, via `MonitorMapLayout`
-(the thin wrapper `monitorMapRoutes` points to).
+This is what the sjvair.com widget uses, via `MonitorMapLayout` (the thin wrapper
+`monitorMapRoutes` points to). `sjvair-mobile` mounts the same route tree through the
+subpath entries described next, so the map stays off its startup path.
 
 ### Keeping the map off a host app's startup path
 
@@ -82,8 +83,8 @@ export const { route, navigate, p, isActive, Router } = createRouter({
   `useMonitorMapRouter`, `ROUTER_KEY`, `MonitorMapRouterApi`) and `monitorsManager`, with
   no map code behind them.
 - `@sjvair/monitor-map/routes` exports a `monitorMapRoutes` with the same route tree, whose
-  layout and routes load on demand. On a cold deep link into the map, the router outlet is
-  empty until that chunk arrives.
+  map layout and monitor panel load on demand. The load screen shows while they do, including
+  on a cold deep link into the map, with a retry if a chunk fails to load.
 
 Both entries share their modules with the package root, so `monitorsManager` is the same
 instance whichever entry it is imported from.
@@ -92,18 +93,57 @@ instance whichever entry it is imported from.
 preload and the map layout): overlapping calls share one set of requests, a failed call can
 be retried, and an explicit `"pm25"`/`"o3"` argument wins over a call without one.
 
+`init()` starts the 2-minute polling when it finishes. A background preload that shows no
+map should pass `{ autoUpdate: false }` (`monitorsManager.init(undefined, { autoUpdate: false })`);
+the map layout starts polling when it mounts. If any call sharing a run wants polling, it
+starts.
+
+### The monitor detail panel
+
+`/monitor/:id` under the map's routes opens a panel for that monitor. It loads the monitor
+itself, so a link works whatever pollutant the map is showing and needs no `?pollutant=`
+parameter: the panel shows the map's pollutant when the monitor reports it and otherwise the
+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`
-component: it wires up every integration, every manager, and the full display-options
-menu. A host that only wants some of that — say, just the monitors integration, with no
+component: it wires up every integration, every manager, and the full options toolbar and
+legend. A host that only wants some of that — say, just the monitors integration, with no
 EV stations/wind/HMS — should compose `MapShell` directly instead:
 
 ```svelte
 <script>
-	import { MapShell, monitorsMapIntegration, monitorsManager, Menu } from "@sjvair/monitor-map";
-
-	monitorsManager.init();
+	import {
+		MapShell,
+		MonitorsMenu,
+		OptionsGroup,
+		PollutantMenu,
+		monitorsMapIntegration,
+		monitorsManager
+	} from "@sjvair/monitor-map";
+
+	let failed = $state(false);
+	function load() {
+		failed = false;
+		monitorsManager.init().catch(() => (failed = true));
+	}
+	load();
 </script>
 
 <MapShell
@@ -113,13 +153,25 @@ EV stations/wind/HMS — should compose `MapShell` directly instead:
 	routerEscapeHatch={false}
 >
 	{#snippet menu()}
-		<Menu>
-			<!-- display options for the integrations you included -->
-		</Menu>
+		<OptionsGroup>
+			<PollutantMenu />
+			<MonitorsMenu />
+		</OptionsGroup>
+	{/snippet}
+	{#snippet loadError()}
+		{#if failed}
+			<button onclick={load}>Couldn't load air monitors. Try again</button>
+		{/if}
 	{/snippet}
 </MapShell>
 ```
 
+The `menu` snippet renders inside the options toolbar; compose `OptionsGroup` with the
+exported menus (`PollutantMenu`, `MonitorsMenu`, `LayersMenu`, `OverlaysMenu`,
+`SettingsMenu`), or `OptionsMenu` with the row components for a custom data source. The
+optional `loadError` snippet renders on the load screen, under the logo, which stays up
+until `ready` is true; use it to show a failed initial load with a retry.
+
 See `src/lib/MonitorMapLayout.svelte` for the reference example of wiring a manager, an
 integration list, and menu/overlay content into `MapShell`.
 
@@ -197,13 +249,13 @@ npm run check        # Type-check Svelte components
 npm run check:watch  # Type-check in watch mode
 npm run lint         # Prettier check + ESLint
 npm run format       # Auto-format with Prettier
+npm test             # Vitest (specs in tests/**)
+npm run test:bundle  # build:lib, then check the light entries keep maplibre off the eager path
 ```
 
-No test framework is currently configured.
-
 ## Publishing
 
 Publishing to npm (`@sjvair/monitor-map`) happens via GitHub Actions
 (`.github/workflows/release-package.yml`) whenever a GitHub Release is published (or the
-workflow is triggered manually). Bump `version` in `package.json` before cutting the
-release.
+workflow is triggered manually). The workflow runs `npm test` and `npm run test:bundle`
+before publishing. Bump `version` in `package.json` before cutting the release.

package/dist/lib/LazyMapLayout.svelte

@@ -0,0 +1,53 @@
+<script lang="ts">
+	import type { Component, Snippet } from "svelte";
+	import LoadScreen from "./LoadScreen.svelte";
+	import LoadError from "./LoadError.svelte";
+	import { loadMonitorDetailPanel, loadMonitorMapLayout } from "./lazy-chunks";
+	import { useMonitorMapRouter } from "./router-context";
+
+	interface Props {
+		children: Snippet;
+	}
+
+	let { children }: Props = $props();
+
+	const { route, basePath } = useMonitorMapRouter();
+
+	let Layout: Component<Props> | null = $state.raw(null);
+	let failed = $state(false);
+
+	function load() {
+		failed = false;
+		loadMonitorMapLayout().then(
+			(module) => (Layout = module.default),
+			(error) => {
+				console.error(error);
+				failed = true;
+			}
+		);
+	}
+
+	load();
+	// On a link straight to a monitor, fetch its panel alongside the layout; the panel's own
+	// wrapper only mounts (and would only ask for it) once the layout has arrived. A failure is
+	// reported by that wrapper when it asks again.
+	if (route.pathname.startsWith(`${basePath}/monitor/`)) {
+		loadMonitorDetailPanel().catch(() => {});
+	}
+</script>
+
+<!-- The layout renders the same LoadScreen from the same shared state, so it carries on
+     from this one without restarting. -->
+{#if Layout}
+	<Layout>{@render children()}</Layout>
+{:else}
+	<div class="relative h-full w-full">
+		<LoadScreen>
+			{#snippet error()}
+				{#if failed}
+					<LoadError message="Couldn't load the map." onretry={load} />
+				{/if}
+			{/snippet}
+		</LoadScreen>
+	</div>
+{/if}

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

@@ -0,0 +1,7 @@
+import type { Component, Snippet } from "svelte";
+interface Props {
+    children: Snippet;
+}
+declare const LazyMapLayout: Component<Props, {}, "">;
+type LazyMapLayout = ReturnType<typeof LazyMapLayout>;
+export default LazyMapLayout;

package/dist/lib/LazyMonitorDetailPanel.svelte

@@ -0,0 +1,33 @@
+<script lang="ts">
+	import type { Component } from "svelte";
+	import LoadError from "./LoadError.svelte";
+	import { loadMonitorDetailPanel } from "./lazy-chunks";
+
+	let Panel: Component | null = $state.raw(null);
+	let failed = $state(false);
+
+	function load() {
+		failed = false;
+		loadMonitorDetailPanel().then(
+			(module) => (Panel = module.default),
+			(error) => {
+				console.error(error);
+				failed = true;
+			}
+		);
+	}
+
+	load();
+</script>
+
+{#if Panel}
+	<Panel />
+{:else}
+	<div class="flex h-full w-full items-center justify-center bg-white">
+		{#if failed}
+			<LoadError message="Couldn't load this monitor." onretry={load} />
+		{:else}
+			<p class="text-sm text-gray-500">Loading…</p>
+		{/if}
+	</div>
+{/if}

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

@@ -0,0 +1,4 @@
+import type { Component } from "svelte";
+declare const LazyMonitorDetailPanel: Component<Record<string, never>, {}, "">;
+type LazyMonitorDetailPanel = ReturnType<typeof LazyMonitorDetailPanel>;
+export default LazyMonitorDetailPanel;

package/dist/lib/LoadError.svelte

@@ -0,0 +1,19 @@
+<script lang="ts">
+	interface Props {
+		message: string;
+		onretry: () => void;
+	}
+
+	let { message, onretry }: Props = $props();
+</script>
+
+<div class="flex flex-col items-center gap-3 px-4 text-center" role="alert">
+	<p class="text-gray-700">{message}</p>
+	<button
+		type="button"
+		class="rounded-md bg-gray-800 px-4 py-2 text-sm font-medium text-white hover:bg-gray-700"
+		onclick={onretry}
+	>
+		Try again
+	</button>
+</div>

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

@@ -0,0 +1,7 @@
+interface Props {
+    message: string;
+    onretry: () => void;
+}
+declare const LoadError: import("svelte").Component<Props, {}, "">;
+type LoadError = ReturnType<typeof LoadError>;
+export default LoadError;

package/dist/lib/LoadScreen.svelte

@@ -23,8 +23,16 @@
 </script>
 
 <script lang="ts">
+	import type { Snippet } from "svelte";
 	import type { Attachment } from "svelte/attachments";
 
+	interface Props {
+		/** Rendered under the logo while the load screen is up, e.g. a load failure and a retry */
+		error?: Snippet;
+	}
+
+	let { error }: Props = $props();
+
 	const animationTrigger: Attachment<HTMLDivElement> = () => {
 		loadScreenState.entered = true;
 	};
@@ -32,7 +40,7 @@
 
 {#if loadScreenState.enabled}
 	<div
-		class="absolute top-0 left-0 z-50 flex h-full w-full items-center justify-center overflow-hidden bg-white"
+		class="absolute top-0 left-0 z-50 flex h-full w-full flex-col items-center justify-center gap-6 overflow-hidden bg-white"
 		{@attach animationTrigger}
 	>
 		<div class="flex justify-around gap-4">
@@ -64,5 +72,6 @@
 				class:opacity-0={!loadScreenState.entered}
 			/>
 		</div>
+		{@render error?.()}
 	</div>
 {/if}

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

@@ -5,21 +5,11 @@ export interface LoadScreenState {
 export declare const loadScreenState: LoadScreenState;
 export declare function enable(): void;
 export declare function disable(): void;
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
+import type { Snippet } from "svelte";
+interface Props {
+    /** Rendered under the logo while the load screen is up, e.g. a load failure and a retry */
+    error?: Snippet;
 }
-declare const LoadScreen: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, string>;
-type LoadScreen = InstanceType<typeof LoadScreen>;
+declare const LoadScreen: import("svelte").Component<Props, {}, "">;
+type LoadScreen = ReturnType<typeof LoadScreen>;
 export default LoadScreen;

package/dist/lib/MonitorDetailPanel.svelte

@@ -1,11 +1,14 @@
 <script lang="ts">
-	import type { ComponentProps } from "svelte";
+	import { untrack, type ComponentProps } from "svelte";
 	import type { SJVAirEntryLevel } from "@sjvair/sdk";
 	import DataBox from "./components/DataBox.svelte";
+	import LoadError from "./LoadError.svelte";
 	import MonitorWidgetModal from "./monitors/components/MonitorWidgetModal.svelte";
 	import MonitorSubscriptionManager from "./monitors/components/MonitorSubscriptionManager.svelte";
 	import DataChart from "./data-chart/DataChart.svelte";
 	import { monitorsManager } from "./";
+	import { MonitorDetailsState } from "./monitors/monitor-details.svelte";
+	import { choosePanelPollutant } from "./monitors/panel-pollutant";
 	import { useMonitorMapRouter } from "./router-context";
 	import { fetchTempByCoords } from "./weather";
 	import { Colors, valueToColor } from "./colors";
@@ -21,24 +24,75 @@
 	}
 	const { route, navigate, basePath } = useMonitorMapRouter();
 
-	const monitor = $derived(monitorsManager.latest?.get(route.params.id ?? ""));
+	// The panel fetches its own monitor: the map's readings only hold monitors that have a
+	// current reading for the map's pollutant.
+	const details = new MonitorDetailsState();
+	const meta = $derived(monitorsManager.meta);
+	// Shown only once the metadata is in too; labels and levels come from it.
+	const monitor = $derived(details.status === "ready" && meta ? details.monitor : null);
+
+	// Through a $derived: the router replaces `route.params` on every navigation, including
+	// a search-only change or Back to the same monitor, which must not reload the panel.
+	const routeId = $derived(route.params.id);
+	$effect(() => {
+		const id = routeId;
+		if (id) untrack(() => details.load(id));
+	});
+
+	// Bumped whenever the map's readings are replaced, i.e. its 2-minute refresh ran. The data
+	// box follows it; the chart decides for itself whether its date range can have new entries.
+	let refreshTick = $state(0);
+	let seenLatest = untrack(() => monitorsManager.latest);
+
+	$effect(() => {
+		const latest = monitorsManager.latest;
+		// Null while a pollutant change is loading; wait for the readings that follow.
+		if (!latest || latest === seenLatest) return;
+		// The first readings of a cold load arrive alongside this panel's own request.
+		const first = seenLatest === null;
+		seenLatest = latest;
+		if (first) return;
+		untrack(() => {
+			details.refresh();
+			refreshTick++;
+		});
+	});
+
+	const panel = $derived(
+		monitor && meta ? choosePanelPollutant(monitorsManager.pollutant, monitor, meta) : null
+	);
+	const reading = $derived(
+		monitor && panel?.pollutant && panel.hasReading ? monitor.latest[panel.pollutant] : undefined
+	);
+	// Set when the panel shows a different pollutant than the map is coloring by.
+	const pollutantNote = $derived.by(() => {
+		const mapPollutant = monitorsManager.pollutant;
+		if (!meta || !panel?.pollutant || !panel.hasReading || !mapPollutant) return;
+		if (panel.pollutant === mapPollutant) return;
+		const shown = meta.entryType(panel.pollutant).label;
+		const label = meta.entryType(mapPollutant).label;
+		// Mid-sentence: lowercase a plain word ("Ozone"), keep a symbol ("PM2.5") as written.
+		const missing = /^[A-Z][a-z]+$/.test(label) ? label.toLowerCase() : label;
+		return `Showing ${shown}. This monitor has no ${missing} readings.`;
+	});
+
 	let tempData: TempDataBox | undefined = $state();
 	const entryData: ComponentProps<typeof DataBox> | undefined = $derived.by(() => {
-		if (!monitor || !monitorsManager.meta) return;
+		if (!monitor || !meta || !panel?.pollutant || !reading) return;
 
-		const entryType = monitorsManager.meta.entryType(monitor.latest.entry_type);
+		const entryType = meta.entryType(panel.pollutant);
 		const level: SJVAirEntryLevel | undefined = getCurrentLevel(
-			monitor.latest.value,
+			reading.value,
 			entryType.asIter.levels!
 		);
 
-		const updateDuration = monitorsManager.meta.monitorType(monitor.type).expected_interval;
+		const updateDuration = meta.monitorType(monitor.type).expected_interval;
 
 		return {
 			color: level?.color ?? "",
 			header: entryType.label,
 			subheading: `(${updateDuration} avg)`,
-			value: Math.round(parseInt(monitor.latest.value, 10)).toString()
+			value: Math.round(parseInt(reading.value, 10)).toString()
 		};
 	});
 
@@ -49,15 +103,26 @@
 		{ min: 95, color: Colors.red }
 	];
 
+	// Re-run for each refreshed copy of the monitor, as before, but never show one monitor's
+	// temperature on another: cleared when the id changes, and a late answer is dropped.
+	let tempMonitorId: string | undefined;
 	$effect(() => {
-		if (monitor && monitor.position) {
-			fetchTempByCoords(monitor.position.coordinates).then((temperature) => {
+		const current = monitor;
+		const id = current?.id;
+		if (id !== tempMonitorId) {
+			tempMonitorId = id;
+			tempData = undefined;
+		}
+		if (!current?.position) return;
+		fetchTempByCoords(current.position.coordinates)
+			.then((temperature) => {
+				if (untrack(() => monitor?.id) !== id) return;
 				tempData = {
 					value: `${temperature}°F`,
 					color: valueToColor(temperature, tempColors)
 				};
-			});
-		}
+			})
+			.catch(console.error);
 	});
 </script>
 
@@ -104,24 +169,37 @@
 				{@render badge("location-on", monitor.county)}
 				{@render badge("location-searching", monitor.location)}
 			</div>
+			{#if pollutantNote}
+				<p class="text-center text-sm text-gray-600">{pollutantNote}</p>
+			{:else if panel && !panel.hasReading}
+				<p class="text-center text-sm text-gray-600">This monitor has no current readings.</p>
+			{/if}
 		{/if}
 	</div>
 
 	<div class="tall:overflow-y-auto flex flex-col items-center gap-12 p-5 pt-10">
-		{#if monitor}
-			<div class="flex w-full justify-around">
-				{#if tempData}
-					<DataBox color={tempData.color} header="Temperature" value={tempData.value} />
-				{/if}
-				{#if entryData}
-					<DataBox
-						color={entryData.color}
-						header={entryData.header}
-						subheading={entryData.subheading}
-						value={entryData.value}
-					/>
-				{/if}
-			</div>
+		{#if details.status === "not-found"}
+			<p class="text-gray-700" role="alert">Monitor not found.</p>
+		{:else if details.status === "failed"}
+			<LoadError message="Couldn't load this monitor." onretry={() => details.retry()} />
+		{:else if !monitor || !panel}
+			<p class="text-sm text-gray-500">Loading…</p>
+		{:else}
+			{#if tempData || entryData}
+				<div class="flex w-full justify-around">
+					{#if tempData}
+						<DataBox color={tempData.color} header="Temperature" value={tempData.value} />
+					{/if}
+					{#if entryData}
+						<DataBox
+							color={entryData.color}
+							header={entryData.header}
+							subheading={entryData.subheading}
+							value={entryData.value}
+						/>
+					{/if}
+				</div>
+			{/if}
 
 			<div class="tall:block hidden">
 				<MonitorWidgetModal monitorId={monitor.id} />
@@ -131,9 +209,11 @@
 				<MonitorSubscriptionManager monitorId={monitor.id} />
 			{/if}
 
-			<div class="w-full">
-				<DataChart {monitor} />
-			</div>
+			{#if panel.pollutant}
+				<div class="w-full">
+					<DataChart {monitor} pollutant={panel.pollutant} {refreshTick} />
+				</div>
+			{/if}
 
 			<div class="w-full">
 				<h3 class="font-semibold">Data Provided Courtesy Of:</h3>

package/dist/lib/MonitorMapLayout.svelte

@@ -14,6 +14,7 @@
 		currentSelection,
 		parsePollutantParam
 	} from "./options/pollutant-param";
+	import LoadError from "./LoadError.svelte";
 	import Legend from "./legend/Legend.svelte";
 	import {
 		fireSmokeLegendSections,
@@ -61,7 +62,19 @@
 		monitorsMapIntegration.enabled = false;
 	}
 
-	monitorsManager.init(route.search.pollutant);
+	// The load screen stays up until the monitors load, so a failure has to be shown on it.
+	let loadFailed = $state(false);
+
+	function loadMonitors() {
+		loadFailed = false;
+		// A rejected init() can be retried: a later call starts a fresh run.
+		monitorsManager.init(route.search.pollutant).catch((error) => {
+			console.error(error);
+			loadFailed = true;
+		});
+	}
+
+	loadMonitors();
 	// A previous instance of this layout stopped polling in onDestroy; init() is a no-op by now.
 	monitorsManager.resumeAutoUpdate();
 	collocationSitesManager.init();
@@ -129,6 +142,11 @@
 	knownRoutes={[`${basePath}/monitor/`]}
 	{basePath}
 >
+	{#snippet loadError()}
+		{#if loadFailed}
+			<LoadError message="Couldn't load air monitors." onretry={loadMonitors} />
+		{/if}
+	{/snippet}
 	{#snippet menu()}
 		<OptionsGroup>
 			<PollutantMenu />

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();