@sjvair/map-sdk 0.1.0-beta.3 → 0.1.0-beta.5

package/README.md

@@ -167,7 +167,22 @@ points only), as sjvair.com's map does today.
 
 `outline` on `shapesPlugin` is `"theme"` (default, a 1px `--foreground` edge), `"level"` (the edge
 in each level's color at the fill's opacity; choropleth only), or `"none"` (no outline layer).
-`hmsSmokePlugin` uses `"level"`.
+`hmsSmokePlugin` uses `"level"`. `hoverable: false` on `shapesPlugin` sets the plugin's
+`hoverable` (see [Writing a plugin](#writing-a-plugin)): hovering a shape shows no tooltip and
+doesn't hide what is beneath it, while focusing it from the feature list still pins its tooltip.
+`hmsSmokePlugin` uses it, so a plume, which can cover much of the map, never pops up a tooltip.
+
+```ts
+map.addPlugin(
+	shapesPlugin({
+		id: "plumes",
+		source: staticSource(plumes, { dataset: "hms-smoke", entryType: "smoke-density" }),
+		layerLabel: "Plumes",
+		mode: "choropleth",
+		hoverable: false
+	})
+);
+```
 
 `zoomRange: { min?, max? }` on `pointsPlugin` limits every layer it draws (points, clusters,
 selection) to camera zooms from `min` (inclusive) up to `max` (exclusive), switching live while
@@ -177,7 +192,12 @@ zooming. Two plugins whose ranges meet hand over with no gap, on the globe too.
 colored by FRP. With `hotspots`, it switches by itself while zooming, as sjvair.com's map does:
 `source` (the fire store's `groups`) below zoom 10 and `hotspots` from zoom 10. It stays one
 layer: one legend section, one feature list (the groups, so keyboard users reach every fire;
-hotspots aren't listed), and tooltips for both.
+hotspots aren't listed), and tooltips for both. The tooltip is the monitors' reading box: "Fire
+(MW)", the power in its level's color, beside the name ("3 fire detections", "1 fire detection"
+for a group, "Fire detection" for one detection) and the level ("50–149 MW"); a group of two or
+more says "Average". A feature with a `count` (`FireFeatureProperties`, which the fire store's
+groups carry) is a group. Fire values are cut off at the display precision, not rounded, in the
+tooltip, the list and its accessible names, so 9.96 MW reads "9.9" beside "<10".
 
 `legendDisplay: "gradient" | "blocks"` on `pointsPlugin` sets how the legend draws a range scale
 (default a gradient; `hmsFirePlugin` uses `"blocks"`, labeled with the levels' own labels). A blocks
@@ -204,6 +224,10 @@ charger") shown where "No level" would be: in the feature list (plain text, no s
 accessible name ("Fresno Station, Level 2 charger"), and the tooltip. A feature with a level
 always shows its level. A plugin of your own sets the same `detail` on its `FeatureListItem`s.
 
+`truncateValues: true` on `pointsPlugin` cuts values off at the display precision instead of
+rounding them (`truncate` on each `FeatureListItem`), in the list, its accessible names, and the
+generic tooltip, so a value never reads as the next level up. `hmsFirePlugin` uses it.
+
 `collocationSitesPlugin({ id?, source, layerLabel })` draws collocation sites as sjvair.com does:
 each at its reference monitor, in that monitor's shape and level color (inactive gray, inside
 outlined), wrapped in a crosshair of `COLLOCATION_CROSSHAIR_COLOR` (`#4A5FC6`, a fixed color on
@@ -229,7 +253,12 @@ and reads "No level"; a level with an empty color draws neutral with its own lab
 source loads, fails, or is unavailable, the legend says so (a failure offers "Try again", which
 calls `status.retry()`). Values are shown with the metadata's display precision, except in the
 monitor, cluster, and collocation tooltips, which match monitor-map: the reading and a cluster's
-average are whole numbers, and a cluster's max and min are as reported.
+average are whole numbers, and a cluster's max and min are as reported. Fire values are cut off
+rather than rounded (see `truncateValues`). Times in the tooltips read like sjvair.com's map, in
+Pacific time: "4:00 pm Friday Nov 06, 2026", with " PT" after them on a device in another zone.
+The monitor cluster tooltip's count line gives the area the monitors are within, "3 monitors
+within a 22.619 mi² area": the area of their convex hull, left out when it would read 0.000 (two
+monitors, or all on one line or one spot).
 
 `createMonitorsStore()` (from `@sjvair/map-sdk/stores`) loads the monitors list and latest readings
 for an entry type, polls every two minutes, and exposes `dataSource`. `init()`, `update()`,
@@ -345,6 +374,19 @@ function sitesPlugin(sites: Sites): MapPlugin {
 }
 ```
 
+An item for a shape (a polygon or line) can carry its `geometry` and, optionally, its `bbox`
+(`[west, south, east, north]`, from `geometryBbox(geometry)`). The list and the summary then count
+it as in view when the shape overlaps the view, not only when its `lngLat` is inside it: a smoke
+plume that fills the screen is listed even though its center is off-screen. Measure `bbox` once per
+data load (both are tested on every move); without it the box is computed each time. Focusing such
+a shape from the list while its `lngLat` is off-screen leaves the camera where it is, and its
+tooltip pins at a point of the shape in view: the view's center (beside the list panel) when the
+shape covers it, else a point inside its visible part. `map.focusedAnchor` is where the focused
+tooltip pins, and `map.anchorFor(item)` gives that point for any item without moving the camera
+(the hover tooltip uses it). `intersectsBounds(item, bounds)` is the in-view test. `shapesPlugin`
+and the presets built on it set `geometry` and `bbox` already. Bounds across the antimeridian are
+not handled.
+
 A plugin can also add a MapLibre custom layer, such as a wind layer from a library you add
 yourself, with `ctx.addCustomLayer(local, create)`. The host calls `create` with the namespaced id
 (the layer must use it) and adds the object it returns as is, in the plugin's draw-order slot. It is
@@ -356,7 +398,10 @@ features are under the pointer, the hover tooltip shows the one whose plugin has
 `hoverPriority` (default 0), the topmost on a tie. Over a cluster bubble, the bubble's tooltip
 shows unless a feature beneath belongs to a plugin with a higher `hoverPriority` than the
 bubble's (collocation sites under monitor clusters). Clicks always go to the topmost, so a click
-on a bubble still zooms into it.
+on a bubble still zooms into it. A plugin with `hoverable: false` never takes the hover: its
+features show no hover tooltip or pointer cursor and are passed over as if they weren't drawn, so
+whatever is beneath gets the hover. They are still clicked, returned by `featuresAt`, and pin
+their tooltip when focused from the feature list.
 
 ```ts
 import type { CustomLayerInterface, MapPlugin, PluginContext } from "@sjvair/map-sdk";
@@ -408,7 +453,8 @@ and `getSelectionMode(id)` are reactive.
 
 `map.on("featureclick", ({ pluginId, ref, lngLat }) => …)` fires for every click on a feature,
 whatever the mode, and also for a pick in the feature list, so keyboard users get the same event;
-`lngLat` is the click point (the item's position for a list pick). It returns an unsubscribe
+`lngLat` is the click point. For a list pick it's where the item's tooltip pins: the item's
+position, or for a shape whose label point is off-screen, a point of the shape in view. It returns an unsubscribe
 function. For your own context menu, `map.featuresAt({ x, y })` returns the hits under
 a canvas point, topmost first, and `map.featureForElement(element)` returns the hit for a row of
 the feature list (an element with `data-mapsdk-ref`). Both return nothing while the map is
@@ -500,6 +546,54 @@ local sjvair.com stack at `http://localhost:8000`.
    podman exec sjvaircom_web_1 python manage.py loaddata default-calibrations.yaml
    ```
 
+## Changes
+
+### 0.1.0-beta.5
+
+- **Shapes that cover the view are in view.** The feature list and the view summary count a shape
+  when it overlaps the view, not only when its center (label point) is inside it. A smoke plume or
+  a big region that fills the screen, with its center off-screen, now has a list row and is
+  counted. Points are unchanged.
+- **Focusing such a shape doesn't move the map.** Before, focusing a row panned to center the
+  shape's label point (a plume's could be off Baja). Now the camera stays, and the tooltip pins at
+  a point of the shape in view, with no move event. A shape whose label point is on screen still
+  pans to it.
+- **Hover tooltips** in `"pinned"` mode follow the same rule: a hovered shape whose label point is
+  off-screen pins its tooltip inside the view instead of at the map's edge. If the map moves while
+  the pointer rests on the shape, the pin is found again when the map settles.
+- **`featureclick` from the list** (Enter on a row) reports that same in-view point for such a
+  shape, instead of its off-screen label point. A handler that pans to `lngLat` no longer sends
+  the map off to the shape's far-away center. Points and on-screen label points report their
+  position, as before.
+- **New API (all optional):** `FeatureListItem.geometry` and `.bbox`, `MapContext.focusedAnchor`
+  and `.anchorFor(item)`, `geometryBbox`, `intersectsBounds`, and the `Bbox` type.
+
+### 0.1.0-beta.4
+
+Defaults from monitor-map 5.0's parity review against sjvair.com's map (4.3.0). Every map gets
+them; none is an option.
+
+- **Tooltip times** read like sjvair.com's map, in Pacific time: "4:00 pm Friday Nov 06, 2026"
+  (was "Nov 6, 2026, 4:00 PM"). A device in another zone still gets " PT" after the time.
+- **The cluster area line is back.** The monitor cluster tooltip's count line reads "3 monitors
+  within a 22.619 mi² area". This reverses the 2026-11-04 parity decision of "no area line". The
+  wording is new (sjvair.com said "covering"), and the area is the convex hull of the cluster's
+  monitors, so clusters of four or more can differ from sjvair.com's number, which followed the
+  monitors' order and could cross itself. No line when the area would read 0.000.
+- **Fire tooltips are the reading box**: "Fire (MW)", the power in its level's color, beside the
+  name and level; "Average" for a group of two or more. Fire values are cut off, not rounded, in
+  the tooltip, the list and its accessible names. Every group names its count, a group of 1
+  included ("1 fire detection").
+- **Smoke plumes show no hover tooltip** and never take the hover from what is beneath them;
+  focusing a plume from the feature list still pins its tooltip. This reverses part of milestone
+  2's accessibility additions ("tooltips on smoke and fire"): fire keeps a tooltip.
+- **Breaking for hosts with their own message catalog:** `mapsdk_hms_fire_detections` is now
+  `mapsdk_hms_fire_detections_one` / `_other`. New keys: `mapsdk_hms_fire_box_header`,
+  `mapsdk_hms_fire_box_header_no_units`, `mapsdk_hms_fire_average`, `mapsdk_level_with_units`,
+  and `mapsdk_monitor_cluster_count_area_one` / `_other`.
+- **New API:** `MapPlugin.hoverable`, `shapesPlugin`'s `hoverable`, `pointsPlugin`'s
+  `truncateValues`, `FeatureListItem.truncate`, and `FireFeatureProperties`.
+
 ## Development
 
 ```bash

package/dist/core/create-map.svelte.d.ts

@@ -5,7 +5,7 @@ import type { FeatureRef, SelectionMode, SpatialSelection } from "../data/types.
 import { BasemapState, type BasemapConfig } from "./basemap.svelte.js";
 import type { GlMapLike } from "./gl.js";
 import { type Hovered } from "./interactions.svelte.js";
-import type { FeatureHit, MapPlugin } from "./plugin.js";
+import type { FeatureHit, FeatureListItem, MapPlugin } from "./plugin.js";
 export interface CameraState {
     center: [number, number];
     zoom: number;
@@ -52,7 +52,10 @@ export interface PluginOptions {
 export type FeatureClickHandler = (e: {
     pluginId: string;
     ref: FeatureRef;
-    /** The click point; for a pick in the feature list, the item's position. */
+    /**
+     * The click point. For a pick in the feature list, where the item's tooltip pins: its position,
+     * or for a shape whose label point is off-screen, a point of the shape in view.
+     */
     lngLat: [number, number];
 }) => void;
 /** Where a camera move ends up. `zoom` wins over `minZoom`. */
@@ -185,6 +188,18 @@ export interface MapContext {
     readonly focusedKey: string | null;
     /** Reactive. The plugin `focusFeature` was given with `focusedKey`, or `null`. */
     readonly focusedPluginId: string | null;
+    /**
+     * Reactive. Where the focused feature's tooltip pins, set by `focusFeature` (`null` without
+     * focus): its `lngLat`, or for a shape that overlaps the view with its `lngLat` off-screen, a
+     * point of the shape in the part of the view the list panel leaves clear. Fixed at focus
+     * time, so it stays on the feature if the map then moves.
+     */
+    readonly focusedAnchor: [number, number] | null;
+    /**
+     * Where `item`'s tooltip pins in the current view, without moving the camera: its `lngLat`,
+     * or for a shape (`geometry`) with its `lngLat` off-screen, a point of the shape in view.
+     */
+    anchorFor(item: FeatureListItem): [number, number];
     /** For MapView only: uses `gl` from now on. */
     attach(gl: GlMapLike): void;
     /** For MapView only: stops using the current GL map. */

package/dist/core/create-map.svelte.js

@@ -7,6 +7,7 @@ import { applyPick, selectionKeys } from "../data/selection.js";
 import { BasemapState } from "./basemap.svelte.js";
 import { InteractionRouter } from "./interactions.svelte.js";
 import { PluginHost } from "./plugin-host.svelte.js";
+import { intersectsBounds, shapeAnchor } from "./shape-view.js";
 /** Monitor-map's start view. */
 const DEFAULT_VIEW = {
     center: [-119.7987626619462, 36.76272050981146],
@@ -36,6 +37,7 @@ function sameSelection(a, b) {
         return a === b;
     return (a.kind === b.kind && a.ids.length === b.ids.length && a.ids.every((id, i) => id === b.ids[i]));
 }
+const inRect = (p, b) => p[0] >= b.west && p[0] <= b.east && p[1] >= b.south && p[1] <= b.north;
 function prefersReducedMotion() {
     return globalThis.matchMedia?.("(prefers-reduced-motion: reduce)").matches ?? false;
 }
@@ -55,6 +57,7 @@ class MapContextImpl {
     #glState = $state.raw(null);
     #focusedKey = $state(null);
     #focusedPluginId = $state(null);
+    #focusedAnchor = $state.raw(null);
     #selections = new SvelteMap();
     #featureClickHandlers = new Set();
     #router = new InteractionRouter();
@@ -63,6 +66,11 @@ class MapContextImpl {
     #destroyed = false;
     #listInset = 0;
     #listInsetSide = "left";
+    /** An animated ease that `focusFeature` started is still running (cleared on `moveend`). */
+    #focusEasing = false;
+    #onMoveEnd = () => {
+        this.#focusEasing = false;
+    };
     constructor(options) {
         const initialView = copyView(options.config.initialView ?? DEFAULT_VIEW);
         this.config = {
@@ -123,6 +131,9 @@ class MapContextImpl {
     get focusedPluginId() {
         return this.#focusedPluginId;
     }
+    get focusedAnchor() {
+        return this.#focusedAnchor;
+    }
     get hovered() {
         return this.#router.hovered;
     }
@@ -178,9 +189,15 @@ class MapContextImpl {
         const found = untrack(() => this.#findItem(refKey, pluginId));
         if (!found)
             return;
-        this.#emitClick(pluginId, found.item.ref, found.item.lngLat);
-        if (found.item.selectable)
-            this.#applyPick(pluginId, found.item.ref, additive);
+        const { item } = found;
+        // Where the row's tooltip pins: the focused anchor for the focused row, else a point of a
+        // shape in view (a point's own position for points and on-screen label points).
+        const focused = untrack(() => this.#focusedKey) === refKey &&
+            (untrack(() => this.#focusedPluginId) ?? pluginId) === pluginId;
+        const anchor = (focused && untrack(() => this.#focusedAnchor)) || this.anchorFor(item);
+        this.#emitClick(pluginId, item.ref, anchor);
+        if (item.selectable)
+            this.#applyPick(pluginId, item.ref, additive);
     }
     clearSelection(pluginId) {
         if (this.#destroyed)
@@ -225,19 +242,101 @@ class MapContextImpl {
             return;
         this.#focusedKey = refKey;
         this.#focusedPluginId = refKey === null ? null : (pluginId ?? null);
+        this.#focusedAnchor = null;
         const gl = this.#gl;
         if (!gl || refKey === null)
             return;
         const found = untrack(() => this.#findItem(refKey, pluginId));
         if (!found)
             return;
+        const { item } = found;
+        const place = this.#placeFor(item, gl);
+        this.#focusedAnchor = place.anchor;
+        if (!place.pan) {
+            // Stays where it is now: an earlier focus's ease that is still running stops here.
+            // With nothing running, no move at all.
+            if (this.#focusEasing) {
+                const { lng, lat } = gl.getCenter();
+                gl.easeTo({ center: [lng, lat], duration: 0 });
+                this.#focusEasing = false;
+            }
+            return;
+        }
+        const reduce = prefersReducedMotion();
         gl.easeTo({
-            center: found.item.lngLat,
+            center: place.anchor,
             // The middle of the part the panel leaves clear. An offset, not padding: MapLibre keeps
             // padding for later moves (zooms, the reported center), an offset applies to this one.
             ...(this.#listInset > 0 && { offset: [this.#listOffsetX(), 0] }),
-            ...(prefersReducedMotion() && { duration: 0 })
+            ...(reduce && { duration: 0 })
         });
+        // Set after the call: stopping an earlier move fires its `moveend` inside `easeTo`.
+        this.#focusEasing = !reduce;
+    }
+    anchorFor(item) {
+        const gl = this.#gl;
+        if (!gl || !item.geometry)
+            return item.lngLat;
+        const { live, clear, liveCenter, clearCenter } = this.#views(gl);
+        if (inRect(item.lngLat, live) || !intersectsBounds(item, live))
+            return item.lngLat;
+        return (shapeAnchor(item.geometry, clear, clearCenter) ??
+            shapeAnchor(item.geometry, live, liveCenter) ??
+            item.lngLat);
+    }
+    /** The live view, and the part of it the list panel leaves clear, with their centers. */
+    #views(gl) {
+        const b = gl.getBounds();
+        const live = {
+            west: b.getWest(),
+            south: b.getSouth(),
+            east: b.getEast(),
+            north: b.getNorth()
+        };
+        const center = gl.getCenter();
+        const width = untrack(() => gl.getCanvas().clientWidth) || 0;
+        const share = width > 0 ? Math.min(Math.max(this.#listInset / width, 0), 0.99) : 0;
+        const cut = share * (live.east - live.west);
+        const clear = this.#listInsetSide === "left"
+            ? { ...live, west: live.west + cut }
+            : { ...live, east: live.east - cut };
+        return {
+            live,
+            clear,
+            liveCenter: [center.lng, center.lat],
+            clearCenter: [(clear.west + clear.east) / 2, center.lat]
+        };
+    }
+    /**
+     * Where focus puts `item`: `pan: false` keeps the camera (a shape in view whose `lngLat` is
+     * off-screen, with a point in the clear part); otherwise ease to center `anchor`.
+     */
+    #placeFor(item, gl) {
+        const { geometry, lngLat } = item;
+        if (!geometry)
+            return { anchor: lngLat, pan: true };
+        const { live, clear, liveCenter, clearCenter } = this.#views(gl);
+        if (inRect(lngLat, live))
+            return { anchor: lngLat, pan: true };
+        if (intersectsBounds(item, live)) {
+            const inClear = shapeAnchor(geometry, clear, clearCenter);
+            if (inClear)
+                return { anchor: inClear, pan: false };
+            const inLive = shapeAnchor(geometry, live, liveCenter);
+            if (inLive)
+                return { anchor: inLive, pan: true };
+        }
+        const settled = untrack(() => this.#bounds);
+        if (settled && intersectsBounds(item, settled)) {
+            const middle = [
+                (settled.west + settled.east) / 2,
+                (settled.south + settled.north) / 2
+            ];
+            const inSettled = shapeAnchor(geometry, settled, middle);
+            if (inSettled)
+                return { anchor: inSettled, pan: true };
+        }
+        return { anchor: lngLat, pan: true };
     }
     #cameraOptions(target, gl) {
         const zoom = target.zoom ??
@@ -281,6 +380,7 @@ class MapContextImpl {
         this.#glState = gl;
         this.#host.attach(gl);
         this.#router.attach(gl);
+        gl.on("moveend", this.#onMoveEnd);
         this.basemap.attach(gl, () => this.#host.restyle(), () => {
             this.#ready = false;
             this.#readyRequested = false;
@@ -291,6 +391,8 @@ class MapContextImpl {
     detach() {
         if (!this.#gl)
             return;
+        this.#gl.off("moveend", this.#onMoveEnd);
+        this.#focusEasing = false;
         this.#router.detach();
         this.basemap.detach();
         this.#host.detach();
@@ -326,6 +428,7 @@ class MapContextImpl {
         this.#featureClickHandlers.clear();
         this.#focusedKey = null;
         this.#focusedPluginId = null;
+        this.#focusedAnchor = null;
         this.#destroyed = true;
     }
     /** A click on a feature: report it, then apply it to the top hit's plugin's selection. */

package/dist/core/interactions.svelte.d.ts

@@ -11,21 +11,23 @@ export interface Hovered {
  * layers, so registrations can come and go without re-binding listeners. Layers nobody registered
  * are never hit. A blocking layer (e.g. a cluster bubble, which zooms instead) is never hit either,
  * and when it is topmost at a point nothing beneath it is hit; only a feature whose plugin
- * outranks it in `hoverPriority` is hovered through it.
+ * outranks it in `hoverPriority` is hovered through it. A non-hoverable plugin's features (e.g.
+ * smoke plumes) are left out of the hover and cursor as if they weren't rendered, but are still
+ * clicked and returned by lookups.
  */
 export declare class InteractionRouter {
     #private;
     /** The top hit under the pointer and where it is. Reactive, for the tooltip. */
     get hovered(): Hovered | null;
     /** Records the layers whose features `toHit` turns into hits. Returns an unregister function. */
-    register(pluginId: string, layerIds: string[], toHit: (props: Record<string, unknown>) => FeatureHit | null, priority?: number): () => void;
+    register(pluginId: string, layerIds: string[], toHit: (props: Record<string, unknown>) => FeatureHit | null, priority?: number, hoverable?: boolean): () => void;
     /**
      * Records layers that hide what is beneath them: when one is topmost at a point, clicks pick
      * nothing (calling `onClick` with that feature instead) and the hover is `toHover`'s hit for
      * it (or nothing). `toHover` must have no side effects: lookups call it too. Returns an
      * unregister function.
      */
-    registerBlocking(pluginId: string, layerIds: string[], toHover?: (props: Record<string, unknown>) => FeatureHit | null, onClick?: (feature: BlockingClick) => void, priority?: number): () => void;
+    registerBlocking(pluginId: string, layerIds: string[], toHover?: (props: Record<string, unknown>) => FeatureHit | null, onClick?: (feature: BlockingClick) => void, priority?: number, hoverable?: boolean): () => void;
     /** Listens to `gl` from now on. */
     attach(gl: GlMapLike): void;
     /** Stops listening and clears `hovered`. */

package/dist/core/interactions.svelte.js

@@ -5,7 +5,9 @@
  * layers, so registrations can come and go without re-binding listeners. Layers nobody registered
  * are never hit. A blocking layer (e.g. a cluster bubble, which zooms instead) is never hit either,
  * and when it is topmost at a point nothing beneath it is hit; only a feature whose plugin
- * outranks it in `hoverPriority` is hovered through it.
+ * outranks it in `hoverPriority` is hovered through it. A non-hoverable plugin's features (e.g.
+ * smoke plumes) are left out of the hover and cursor as if they weren't rendered, but are still
+ * clicked and returned by lookups.
  */
 export class InteractionRouter {
     // Bookkeeping only; nothing reads these reactively.
@@ -28,8 +30,15 @@ export class InteractionRouter {
         return this.#hovered;
     }
     /** Records the layers whose features `toHit` turns into hits. Returns an unregister function. */
-    register(pluginId, layerIds, toHit, priority = 0) {
-        return this.#add({ pluginId, layerIds: [...layerIds], toHit, blocking: false, priority });
+    register(pluginId, layerIds, toHit, priority = 0, hoverable = true) {
+        return this.#add({
+            pluginId,
+            layerIds: [...layerIds],
+            toHit,
+            blocking: false,
+            priority,
+            hoverable
+        });
     }
     /**
      * Records layers that hide what is beneath them: when one is topmost at a point, clicks pick
@@ -37,14 +46,15 @@ export class InteractionRouter {
      * it (or nothing). `toHover` must have no side effects: lookups call it too. Returns an
      * unregister function.
      */
-    registerBlocking(pluginId, layerIds, toHover, onClick, priority = 0) {
+    registerBlocking(pluginId, layerIds, toHover, onClick, priority = 0, hoverable = true) {
         return this.#add({
             pluginId,
             layerIds: [...layerIds],
             toHit: toHover ?? (() => null),
             blocking: true,
             onClick,
-            priority
+            priority,
+            hoverable
         });
     }
     #add(registration) {
@@ -94,7 +104,8 @@ export class InteractionRouter {
         const found = this.#lookup(point);
         return found.blocked ? [] : found.hits;
     }
-    #lookup(point) {
+    /** What is under one point; with `forHover`, non-hoverable features are left out first. */
+    #lookup(point, forHover = false) {
         const none = { hits: [], hover: null, blocked: false, blocker: null, blockedBy: null };
         const gl = this.#gl;
         if (!gl)
@@ -103,6 +114,8 @@ export class InteractionRouter {
         /* eslint-disable svelte/prefer-svelte-reactivity */
         const byLayer = new Map();
         for (const registration of this.#registrations) {
+            if (forHover && !registration.hoverable)
+                continue;
             for (const id of registration.layerIds) {
                 // MapLibre errors on querying a missing layer (e.g. mid basemap change).
                 if (!byLayer.has(id) && gl.getLayer(id))
@@ -210,7 +223,7 @@ export class InteractionRouter {
         }
     };
     #onMove = (e) => {
-        const found = this.#lookup([e.point.x, e.point.y]);
+        const found = this.#lookup([e.point.x, e.point.y], true);
         const hit = found.blocked ? (found.hover ?? found.blocker) : found.hover;
         this.#hovered = hit ? { hit, lngLat: [e.lngLat.lng, e.lngLat.lat] } : null;
         this.#setPointer(found.blocked || hit !== null);

package/dist/core/plugin-host.svelte.js

@@ -406,12 +406,12 @@ export class PluginHost {
             interactive(layerIds, toHit) {
                 if (running.dead)
                     return;
-                running.unregisters.push(router.register(pluginId, layerIds, toHit, running.plugin.hoverPriority ?? 0));
+                running.unregisters.push(router.register(pluginId, layerIds, toHit, running.plugin.hoverPriority ?? 0, running.plugin.hoverable ?? true));
             },
             blocking(layerIds, toHover, onClick) {
                 if (running.dead)
                     return;
-                running.unregisters.push(router.registerBlocking(pluginId, layerIds, toHover, onClick, running.plugin.hoverPriority ?? 0));
+                running.unregisters.push(router.registerBlocking(pluginId, layerIds, toHover, onClick, running.plugin.hoverPriority ?? 0, running.plugin.hoverable ?? true));
             },
             on(type, layerId, listener) {
                 if (running.dead)

package/dist/core/plugin.d.ts

@@ -46,7 +46,26 @@ export interface FeatureListItem {
      * metadata's display hint). Without it the value is formatted as given.
      */
     precision?: number;
+    /**
+     * Cut a numeric `value` off at `precision` instead of rounding it, so the number never reads
+     * as the next level (e.g. fire power: 9.96 MW shows "9.9", not "10.0", beside "<10"). Default
+     * false.
+     */
+    truncate?: boolean;
     lngLat: [number, number];
+    /**
+     * The feature's shape. When given, the item is in view (the feature list, the view summary)
+     * when the shape overlaps the view, not only when `lngLat` is inside it, and focusing or
+     * hovering it while `lngLat` is off-screen pins its tooltip at a point of the shape in view
+     * (focus then leaves the camera where it is).
+     */
+    geometry?: Geometry;
+    /**
+     * `geometry`'s bounding box, `[west, south, east, north]` (`geometryBbox`). Optional; computed
+     * from `geometry` when missing. A plugin listing many shapes should measure it once per data
+     * load, since the list and summary test every item on every move.
+     */
+    bbox?: [number, number, number, number];
     selectable: boolean;
     /**
      * A short text about a feature with no level (e.g. "Level 2 charger"), shown where its level
@@ -139,6 +158,12 @@ export interface MapPlugin {
      * Clicks ignore this (topmost first), and a blocking layer on top still blocks them.
      */
     hoverPriority?: number;
+    /**
+     * False: the plugin's features never take the hover (so no hover tooltip and no pointer
+     * cursor) and never hide a feature beneath from it, as if they weren't rendered. Clicks,
+     * `featuresAt`, and keyboard focus from the list are unchanged. Default true.
+     */
+    hoverable?: boolean;
     displayOptions?: Snippet;
     /** Richer tooltip content for one of this plugin's features, below its name. */
     tooltip?(item: FeatureListItem): Snippet | undefined;

package/dist/core/shape-view.d.ts

@@ -0,0 +1,27 @@
+import type { Geometry } from "geojson";
+import type { Bounds } from "./create-map.svelte.js";
+/**
+ * Shapes against the view: a geometry's bounding box, whether it overlaps the view, and a point of
+ * it inside the view. Coordinates are planar lng/lat (as `labelPoint`); no antimeridian handling.
+ */
+/** `[west, south, east, north]`. */
+export type Bbox = [west: number, south: number, east: number, north: number];
+/** The geometry's bounding box, or `null` when it has no coordinates. */
+export declare function geometryBbox(geometry: Geometry): Bbox | null;
+/** Inside an outer ring and outside its holes, for any polygon of the geometry. */
+export declare function containsPoint(geometry: Geometry, p: [number, number]): boolean;
+/**
+ * Whether the item is in view: a shape (`geometry`) when it intersects `bounds` (bbox pre-check,
+ * then the exact test; holes count), anything else when its `lngLat` is inside. Edges included.
+ */
+export declare function intersectsBounds(item: {
+    lngLat: [number, number];
+    geometry?: Geometry;
+    bbox?: Bbox;
+}, bounds: Bounds): boolean;
+/**
+ * A point of the shape inside `view`: `center` when the shape contains it; otherwise a point well
+ * inside the shape's visible part (polygons: the largest clipped one, never in a hole; lines: the
+ * middle of the longest visible piece); `null` when nothing of it is visible.
+ */
+export declare function shapeAnchor(geometry: Geometry, view: Bounds, center: [number, number]): [number, number] | null;