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

package/dist/presets/CollocationTooltip.svelte

@@ -0,0 +1,132 @@
+<script lang="ts">
+	import type { FormatProvider } from "../data/format.js";
+	import type { MessageProvider } from "../data/messages.js";
+	import { levelFor, NO_LEVEL, numericValue } from "../data/scale.js";
+	import type { Scale } from "../data/scale-types.js";
+	import type { CollocationFeatureProperties } from "../data/types.js";
+	import { formatValue } from "../ui/value-format.js";
+	import MonitorReadingBox from "./MonitorReadingBox.svelte";
+
+	// Ported from monitor-map's CollocationTooltip: the reference monitor's reading beside its
+	// details, then the collocated monitor's with the box on the other side. Readings are whole
+	// numbers cut off, not rounded, as monitor-map's. The reference monitor's own name is shown
+	// here (the site's name when it isn't loaded), not above.
+
+	interface Props {
+		site: CollocationFeatureProperties;
+		scale: Scale | null;
+		messages: MessageProvider;
+		format: FormatProvider;
+		/** How often each monitor's type reports (e.g. "1 hour"); null leaves its note out. */
+		referenceInterval: string | null;
+		colocatedInterval: string | null;
+	}
+
+	let { site, scale, messages, format, referenceInterval, colocatedInterval }: Props = $props();
+
+	function side(
+		name: string | null,
+		role: string,
+		value: number | null,
+		timestamp: string | null,
+		interval: string | null
+	) {
+		const found = scale ? levelFor(value, scale) : NO_LEVEL;
+		const level = found !== NO_LEVEL ? found : null;
+		const n = numericValue(value);
+		const valid = !!timestamp && !Number.isNaN(Date.parse(timestamp));
+		const zone = format.zoneLabel();
+		const formatted = valid ? format.dateTime(timestamp!) : null;
+		return {
+			name,
+			role,
+			color: level?.color || null,
+			level: level ? level.label : messages("mapsdk_no_level"),
+			reading: n === null ? null : formatValue(Math.trunc(n), 0, format),
+			subheading: interval ? messages("mapsdk_collocation_interval_avg", { interval }) : undefined,
+			at:
+				formatted && zone
+					? messages("mapsdk_time_with_zone", { time: formatted, zone })
+					: formatted,
+			ago: valid
+				? messages("mapsdk_collocation_updated", { when: format.relativeTime(timestamp!) })
+				: null
+		};
+	}
+
+	const sides = $derived([
+		side(
+			site.referenceName ?? site.name,
+			messages("mapsdk_collocation_reference"),
+			numericValue(site.value),
+			site.timestamp ?? null,
+			referenceInterval
+		),
+		side(
+			site.colocatedName,
+			messages("mapsdk_collocation_colocated"),
+			site.colocatedValue,
+			site.colocatedTimestamp,
+			colocatedInterval
+		)
+	]);
+</script>
+
+<div class="mapsdk-collocation-tip mapsdk-tooltip-wide">
+	{#each sides as entry, i (i)}
+		<div class="mapsdk-collocation-row" class:reverse={i === 1}>
+			<MonitorReadingBox
+				color={entry.color}
+				header={scale?.label ?? ""}
+				value={entry.reading ?? messages("mapsdk_no_reading")}
+				large={entry.reading !== null}
+				subheading={entry.subheading}
+			/>
+			<div class="mapsdk-collocation-detail">
+				{#if entry.at}
+					<span>{entry.at}</span>
+				{/if}
+				{#if entry.name}
+					<span class="mapsdk-collocation-name text-lg">{entry.name}</span>
+				{/if}
+				<span>{entry.role}</span>
+				<span>{entry.level}</span>
+				{#if entry.ago}
+					<span class="mapsdk-collocation-ago text-base">{entry.ago}</span>
+				{/if}
+			</div>
+		</div>
+	{/each}
+</div>
+
+<style>
+	.mapsdk-collocation-tip {
+		display: flex;
+		flex-direction: column;
+		gap: 1rem;
+	}
+
+	.mapsdk-collocation-row {
+		display: flex;
+		gap: 0.5rem;
+	}
+
+	.mapsdk-collocation-row.reverse {
+		flex-direction: row-reverse;
+	}
+
+	.mapsdk-collocation-detail {
+		display: flex;
+		flex-direction: column;
+		gap: 0.25rem;
+	}
+
+	.mapsdk-collocation-name {
+		font-weight: 700;
+		text-decoration: underline;
+	}
+
+	.mapsdk-collocation-ago {
+		margin-top: auto;
+	}
+</style>

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

@@ -0,0 +1,16 @@
+import type { FormatProvider } from "../data/format.js";
+import type { MessageProvider } from "../data/messages.js";
+import type { Scale } from "../data/scale-types.js";
+import type { CollocationFeatureProperties } from "../data/types.js";
+interface Props {
+    site: CollocationFeatureProperties;
+    scale: Scale | null;
+    messages: MessageProvider;
+    format: FormatProvider;
+    /** How often each monitor's type reports (e.g. "1 hour"); null leaves its note out. */
+    referenceInterval: string | null;
+    colocatedInterval: string | null;
+}
+declare const CollocationTooltip: import("svelte").Component<Props, {}, "">;
+type CollocationTooltip = ReturnType<typeof CollocationTooltip>;
+export default CollocationTooltip;

package/dist/presets/MonitorClusterTooltip.svelte

@@ -0,0 +1,149 @@
+<script lang="ts">
+	import type { FormatProvider } from "../data/format.js";
+	import type { MessageProvider } from "../data/messages.js";
+	import type { MetadataProvider } from "../data/metadata.js";
+	import { levelFor, NO_LEVEL, numericValue } from "../data/scale.js";
+	import type { Scale } from "../data/scale-types.js";
+	import type { MonitorFeatureProperties } from "../data/types.js";
+	import type { ClusterInfo } from "../plugins/points-clusters.js";
+	import { formatValue } from "../ui/value-format.js";
+	import MonitorReadingBox from "./MonitorReadingBox.svelte";
+
+	// Ported from monitor-map's MonitorClusterTooltip: the cluster's average in a level-colored
+	// box beside its monitor type, count, and highest and lowest readings. The count and average
+	// come from the bubble itself, so they show at once; the rest fills in from the cluster's
+	// monitors. The average is a whole number and max and min are as reported, as monitor-map's.
+
+	interface Props {
+		cluster: ClusterInfo<MonitorFeatureProperties>;
+		scale: Scale | null;
+		messages: MessageProvider;
+		format: FormatProvider;
+		metadata: MetadataProvider;
+	}
+
+	let { cluster, scale, messages, format, metadata }: Props = $props();
+
+	/** From the cluster's monitors, once they load. */
+	interface Leaves {
+		isSjvair: boolean;
+		/** Readings only; monitors without one are left out. */
+		values: number[];
+	}
+
+	let leaves = $state.raw<Leaves | null>(null);
+	/** True once the monitors loaded or failed to. */
+	let settled = $state(false);
+	let typeLabel = $state<string | null>(null);
+
+	$effect(() => {
+		const controller = new AbortController();
+		const { group } = cluster;
+		leaves = null;
+		settled = false;
+		typeLabel = null;
+		metadata.monitorTypeLabel(group, controller.signal).then(
+			(label) => {
+				if (!controller.signal.aborted) typeLabel = label === "unavailable" ? group : label;
+			},
+			() => {
+				if (!controller.signal.aborted) typeLabel = group;
+			}
+		);
+		cluster.leaves().then(
+			(found) => {
+				if (controller.signal.aborted) return;
+				settled = true;
+				if (found.length === 0) return;
+				leaves = {
+					isSjvair: found[0].props.isSjvair,
+					values: found.flatMap(({ props }) => {
+						const n = numericValue(props.value);
+						return n === null ? [] : [n];
+					})
+				};
+			},
+			() => {
+				if (!controller.signal.aborted) settled = true;
+			}
+		);
+		return () => controller.abort();
+	});
+
+	/**
+	 * The bubble's own average (its readings' sum over their count), unrounded: the level comes
+	 * from it, as the bubble's color does. Only the number shown is rounded.
+	 */
+	const mean = $derived.by(() => {
+		const sum = cluster.properties.sumValues;
+		const count = cluster.properties.countValues;
+		if (typeof sum !== "number" || typeof count !== "number" || count <= 0) return null;
+		return sum / count;
+	});
+	const average = $derived(mean === null ? null : formatValue(mean, 0, format));
+	const level = $derived.by(() => {
+		if (mean === null || !scale) return null;
+		const found = levelFor(mean, scale);
+		return found !== NO_LEVEL ? found : null;
+	});
+	const units = $derived(scale?.units ?? "");
+	const max = $derived(leaves?.values.length ? Math.max(...leaves.values) : null);
+	const min = $derived(leaves?.values.length ? Math.min(...leaves.values) : null);
+</script>
+
+<div class="mapsdk-monitor-tip mapsdk-tooltip-wide">
+	<MonitorReadingBox
+		color={level?.color || null}
+		header={scale?.label ?? ""}
+		value={average ?? messages("mapsdk_no_reading")}
+		large={average !== null}
+		subheading={messages("mapsdk_monitor_cluster_average")}
+	/>
+	<div class="mapsdk-monitor-detail">
+		{#if typeLabel !== null && settled}
+			<span class="mapsdk-monitor-title text-lg">
+				{messages(
+					leaves?.isSjvair ? "mapsdk_monitor_cluster_title_sjvair" : "mapsdk_monitor_cluster_title",
+					{ type: typeLabel }
+				)}
+			</span>
+		{/if}
+		<span>{messages("mapsdk_monitor_cluster_count", { count: cluster.pointCount })}</span>
+		<span>{level ? level.label : messages("mapsdk_no_level")}</span>
+		{#if max !== null && min !== null}
+			<span class="mapsdk-monitor-extremes text-base">
+				{messages("mapsdk_monitor_cluster_max", {
+					value: formatValue(max, undefined, format),
+					units
+				})}
+			</span>
+			<span class="text-base">
+				{messages("mapsdk_monitor_cluster_min", {
+					value: formatValue(min, undefined, format),
+					units
+				})}
+			</span>
+		{/if}
+	</div>
+</div>
+
+<style>
+	.mapsdk-monitor-tip {
+		display: flex;
+		gap: 0.5rem;
+	}
+
+	.mapsdk-monitor-title {
+		font-weight: 700;
+	}
+
+	.mapsdk-monitor-extremes {
+		margin-top: auto;
+	}
+
+	.mapsdk-monitor-detail {
+		display: flex;
+		flex-direction: column;
+		gap: 0.25rem;
+	}
+</style>

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

@@ -0,0 +1,16 @@
+import type { FormatProvider } from "../data/format.js";
+import type { MessageProvider } from "../data/messages.js";
+import type { MetadataProvider } from "../data/metadata.js";
+import type { Scale } from "../data/scale-types.js";
+import type { MonitorFeatureProperties } from "../data/types.js";
+import type { ClusterInfo } from "../plugins/points-clusters.js";
+interface Props {
+    cluster: ClusterInfo<MonitorFeatureProperties>;
+    scale: Scale | null;
+    messages: MessageProvider;
+    format: FormatProvider;
+    metadata: MetadataProvider;
+}
+declare const MonitorClusterTooltip: import("svelte").Component<Props, {}, "">;
+type MonitorClusterTooltip = ReturnType<typeof MonitorClusterTooltip>;
+export default MonitorClusterTooltip;

package/dist/presets/MonitorReadingBox.svelte

@@ -0,0 +1,58 @@
+<script lang="ts">
+	import { levelChip } from "../ui/level-chip.js";
+
+	// monitor-map's DataBox: a reading in a box filled with its level's color.
+
+	interface Props {
+		/** The level color; null or unparseable → the neutral box. */
+		color: string | null;
+		header: string;
+		value: string;
+		/** Shows `value` large (a reading rather than a "No reading" note). */
+		large: boolean;
+		subheading?: string;
+	}
+
+	let { color, header, value, large, subheading }: Props = $props();
+
+	const style = $derived.by(() => {
+		const chip = levelChip(color);
+		return chip
+			? `background:${chip.background};border-color:${chip.border};color:${chip.text}`
+			: "";
+	});
+</script>
+
+<div class="mapsdk-reading-box" class:neutral={!style} {style}>
+	{#if header}
+		<span class="text-base">{header}</span>
+	{/if}
+	<span class="mapsdk-reading-value" class:text-3xl={large}>{value}</span>
+	{#if subheading}
+		<span>{subheading}</span>
+	{/if}
+</div>
+
+<style>
+	.mapsdk-reading-box {
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		justify-content: center;
+		padding: 0.25rem;
+		border: 4px solid;
+		border-radius: calc(var(--radius-control, var(--radius)) / 2);
+		text-align: center;
+		white-space: nowrap;
+	}
+
+	.mapsdk-reading-box.neutral {
+		border-color: var(--border);
+		background: var(--muted);
+		color: var(--muted-foreground);
+	}
+
+	.mapsdk-reading-value {
+		font-weight: 700;
+	}
+</style>

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

@@ -0,0 +1,12 @@
+interface Props {
+    /** The level color; null or unparseable → the neutral box. */
+    color: string | null;
+    header: string;
+    value: string;
+    /** Shows `value` large (a reading rather than a "No reading" note). */
+    large: boolean;
+    subheading?: string;
+}
+declare const MonitorReadingBox: import("svelte").Component<Props, {}, "">;
+type MonitorReadingBox = ReturnType<typeof MonitorReadingBox>;
+export default MonitorReadingBox;

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/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[];