@nika-js/onlymap 0.6.1 → 0.6.2

package/dist/data-layer.d.ts

@@ -90,6 +90,14 @@ export interface DataFormat {
 export declare function rowsToColumnar(rows: Record<string, unknown>[]): ColumnarData | undefined;
 /** `OmMap.registerFormat(format)` — plug in a parser for a format the library doesn't ship (spec: "v0.2 / Tier 1"). */
 export declare function registerFormat(format: DataFormat): void;
+/** Opaque controller/element identity used to reference-count data transports. */
+export type DataTransportOwner = object;
+/** Start one descriptor reconciliation transaction for an owner. */
+export declare function beginDataOwnerUpdate(owner: DataTransportOwner): void;
+/** Release transports no longer named by the owner's complete descriptor document. */
+export declare function endDataOwnerUpdate(owner: DataTransportOwner): void;
+/** Release every fetch/poller/socket held by an owner (unmount, dispose, or suspend). */
+export declare function releaseDataOwner(owner: DataTransportOwner): void;
 /**
  * A source plugin supplies domain decoding (and optionally a subscription
  * handshake); the transport (WebSocket, reconnect, flush) is generic.
@@ -128,7 +136,7 @@ export interface DataRequestConfig {
 }
 export declare function configureData(config: DataRequestConfig): void;
 /** @internal Shared request-policy chokepoint for non-row assets (ImageOverlay); not re-exported from the package root. */
-export declare function fetchConfiguredResource(url: string): Promise<Response>;
+export declare function fetchConfiguredResource(url: string, signal?: AbortSignal): Promise<Response>;
 /** @internal Shared Content-Length license backstop for row and non-row sources. */
 export declare function assertFetchSizeWithinEntitlement(response: Response): void;
 /** `data="draw:sketch"` — the reserved scheme for a widget-fed sketch layer (never collides with http/ws/inline). */
@@ -162,9 +170,9 @@ export declare function getDrawData(url: string): LayerData;
  * call for a given URL, and invokes `onLoaded` on every resolution/flush (the
  * caller re-reconciles from there).
  */
-export declare function getData(url: string, onLoaded: () => void, opts?: StreamOptions): LayerData;
+export declare function getData(url: string, onLoaded: () => void, opts?: StreamOptions, owner?: DataTransportOwner): LayerData;
 /** Is a fetch for this URL still in flight? Feeds the `om-map-ready` signal — errored fetches count as settled (readiness must not hang on a bad URL). */
-export declare function isPendingData(url: string): boolean;
+export declare function isPendingData(url: string, owner?: DataTransportOwner): boolean;
 /**
  * Minimal feature-shape detection (spec: "Feature Field Resolution & Data
  * Shape" — full per-layer caching/registry treatment is a later phase; this

package/dist/draw-controller.d.ts

@@ -22,6 +22,49 @@ export declare class DrawController {
     private readonly autosaveKeys;
     private readonly observers;
     private active;
+    /**
+     * rAF handle coalescing hover-driven preview updates (spec: "Cut/fill
+     * volume measurement" — found debugging click-reliability in standalone
+     * mode). `point()` used to call `renderPreview()` (which patches the
+     * per-frame channel and rebuilds every deck.gl layer) SYNCHRONOUSLY on
+     * every raw mousemove — far more often than the "per-frame" name implies,
+     * since mousemove fires at native pointer-event rate, not rAF rate. That
+     * rebuild storm intermittently corrupted deck.gl's own click/pick pipeline
+     * (mjolnir gesture recognition losing a click shortly after a hover-driven
+     * rebuild) — confirmed by disabling hover-triggered rebuilds entirely and
+     * watching the click-loss disappear. Coalescing to one rebuild per actual
+     * animation frame is what `patchAnimatedProps`'s own doc comment already
+     * describes as "the deck-idiomatic rAF pattern" — this was a gap between
+     * that intent and this call site, not a design change.
+     */
+    private hoverRaf;
+    /**
+     * The coordinate `commit()` just used to close a shape (its live cursor
+     * position at that moment), or null. The native `dblclick` DOM event
+     * (which drives `commit()`) fires as soon as the second tap's mouseup
+     * lands — but deck.gl's own click-gesture recognition is independently
+     * delayed (Hammer's Tap recognizer defers confirming a "click" until it's
+     * sure a second tap isn't coming, per its `requireFailure`/`interval`
+     * mechanics). One of the double-click's own two taps can therefore still
+     * arrive here as a late, ordinary "click" a few ms *after* commit() already
+     * ran, at ~that same coordinate — with pending now empty, session.click's
+     * own same-spot dedup (see `point()`'s click branch) has nothing to
+     * compare against, so it silently starts a fresh one-vertex shape at the
+     * spot the user just finished closing.
+     *
+     * Guarding on position (not a time window) is what keeps this from
+     * swallowing a genuinely new, deliberate click that happens to follow
+     * immediately after a commit — e.g. redrawing a second shape back-to-back
+     * in a test with no elapsed wall-clock time — since that click lands at a
+     * different coordinate and passes straight through. The match is a small
+     * PIXEL-radius tolerance (see `point()`), not exact equality: a real
+     * double-click's two taps are two independent physical presses and rarely
+     * land at the bit-identical screen pixel, let alone the bit-identical
+     * unprojected lng/lat — exact equality let real hand jitter slip past the
+     * guard even though a synthetic, pixel-perfect test wouldn't reveal that.
+     * Consumed (cleared) by the very next click regardless of whether it matched.
+     */
+    private lastClosePos;
     constructor(mapEl: Element, core: RuntimeCore);
     /** A draw tool is active — om-map routes points here and suppresses selection. */
     isCapturing(): boolean;
@@ -32,14 +75,45 @@ export declare class DrawController {
      * geodesic readouts + labels live off the shared draw stack. `null` unsubs.
      */
     setObserver(target: string, cb: ((session: DrawSession) => void) | null): void;
+    /** This map's own committed-feature count for `target` (spec: "Cut/fill volume measurement") — see DrawSession.count's doc comment for why this beats reading the shared getDrawData mirror. */
+    featureCount(target: string): number;
     private notify;
-    /** Enable localStorage autosave for a target and restore any saved sketch (draw-config action). */
+    /** Enable localStorage autosave for a target and restore any saved sketch, and/or an auto-styled committed-geometry layer (draw-config action). */
     configure(target: string, opts: {
         autosave?: string;
+        fillColor?: number[];
+        lineColor?: number[];
     }): void;
+    /**
+     * Opt-in committed-geometry visualization (spec: issue #34's region-export
+     * demo surfaced this — a closed shape with no author-added layer is
+     * indistinguishable from "double-click didn't work," since the ONLY
+     * built-in visual is the in-progress preview, which clears the instant a
+     * shape commits). Bound directly to the SAME reactive `draw:<target>` data
+     * URL an author's own manual layer would use — this is pure convenience
+     * layered on top, not a replacement; an author who wants custom styling
+     * (or a non-GeoJsonLayer rendering) still adds their own layer instead,
+     * and both can coexist. One committed layer per TARGET (not a singleton
+     * like `PREVIEW_ID`), since multiple draw targets can exist on one map.
+     *
+     * `depthTest: false` (patched, not attribute-expressible — same non-
+     * string-prop precedent as the volume gizmo's `mesh`): a flat 2D ring has
+     * no z of its own, so on a page with 3D content (the exact case this was
+     * built for — outlining a footprint over a BIM building to export) it can
+     * sit at an elevation UNDER opaque building geometry, fully occluded from
+     * a normal camera angle — the identical depth-occlusion class already
+     * fixed for the measure tool's cut-prism guides. This is a SELECTION
+     * indicator, not real in-world geometry, so it's correct for it to always
+     * read on top regardless of what 3D content surrounds it.
+     */
+    private ensureCommittedLayer;
     setMode(target: string, mode: DrawMode | null): void;
     private deactivate;
     point(coord: [number, number] | null, kind: "click" | "hover"): void;
+    /** Drop a queued hover-coalesced render (a following immediate render already supersedes it). */
+    private cancelHoverRaf;
+    /** `CLOSE_GUARD_PIXELS` converted to real meters at the current zoom/latitude (standard Web Mercator meters-per-pixel). */
+    private closeGuardMeters;
     /** Close the in-progress line/polygon — from the double-click DOM event or Enter. */
     commit(): void;
     cancel(): void;

package/dist/draw.d.ts

@@ -50,6 +50,7 @@ export interface DrawSessionOpts {
     /** Fired whenever the COMMITTED feature set changes (commit / delete / clear / seed) — D2 wires this to the store push. */
     onChange?: (fc: FeatureCollection) => void;
 }
+export declare function samePoint(a: Position, b: Position): boolean;
 /**
  * One sketch session. Owns the committed features and the single in-progress
  * shape. Every mutation that changes the committed set fires `onChange` once.
@@ -74,10 +75,16 @@ export declare class DrawSession {
     /** Cursor moved — updates the rubber-band target. No committed-set change. */
     move(pos: Position): void;
     /**
-     * Finalize the in-progress line/polygon (from double-click / Enter). A
-     * trailing duplicate vertex — the second click of a double-click — is
-     * dropped first. No-op (shape kept pending) if there aren't enough
-     * distinct vertices yet. Returns the committed feature or null.
+     * Finalize the in-progress line/polygon (from double-click / Enter). The
+     * two clicks that make up a double-click are individually unreliable —
+     * deck.gl's click/dblclick gesture disambiguation can drop either or both
+     * of them depending on exact timing — so rather than depend on them having
+     * landed in `pending`, the closing vertex is the live cursor position
+     * (already updated by the hover that preceded the double-click, via a
+     * separate, non-gesture-gated code path). A trailing duplicate — the
+     * cursor exactly repeating the last real vertex — is dropped. No-op (shape
+     * kept pending) if there aren't enough distinct vertices yet. Returns the
+     * committed feature or null.
      */
     commit(): DrawFeature | null;
     /** Esc — discard the in-progress shape, keep the tool active. */
@@ -93,6 +100,17 @@ export declare class DrawSession {
         features?: unknown;
     } | null | undefined): void;
     toFeatureCollection(): FeatureCollection;
+    /**
+     * Committed-feature count for THIS session object (spec: "Cut/fill volume
+     * measurement"). Distinct from reading the shared `getDrawData` store
+     * mirror: that mirror is a module-global `Map` keyed by URL string with no
+     * per-map/per-session isolation, so it can carry a PRIOR session's data
+     * (a different `<om-map>` sharing the same runtime-internal target id, or —
+     * the case that surfaced this — a freshly re-mounted map in a test) until
+     * this session's own first commit overwrites it. This reads `this.features`
+     * directly, which always starts empty for a genuinely new session.
+     */
+    count(): number;
     /** The in-progress shape for the preview layer, or null when nothing is pending. */
     preview(): DrawPreview | null;
     private finalize;

package/dist/elements/om-map.d.ts

@@ -20,6 +20,7 @@
 import { HTMLElementBase } from "../env";
 import { type RuntimeContext } from "../ctx";
 import { type LightingIR } from "../scene-lighting";
+import { type ClipBoxIR } from "../clip-box";
 import { type TerrainIR } from "../terrain";
 import { type WidgetSlot } from "../widget-layout";
 import { type SnapshotOptions } from "../snapshot";
@@ -44,10 +45,12 @@ export declare class OmMapElement extends HTMLElementBase {
     private observer;
     private history;
     private keydownHandler?;
+    private keyupHandler?;
     private dblclickHandler?;
     private contextmenuHandler?;
     private mount;
     private reconcilePending;
+    private readonly dataOwner;
     /** Decoded property tables per pick-features layer — see RuntimeCoreCallbacks.onFeatureTable. */
     private featureTables;
     private layerIRs;
@@ -257,6 +260,20 @@ export declare class OmMapElement extends HTMLElementBase {
      *  Fires at pointer rate on hover (no debounce — vertex capture needs
      *  every point); heavy listeners should throttle their own work. */
     private handleMapPoint;
+    /**
+     * XY snapping's snap-tip (spec: issue #34 Part A — "a snap tip shows
+     * which agent fired on which layer, otherwise users can't tell why a
+     * vertex jumped"). A SEPARATE runtime overlay from the shared
+     * `show-tooltip` singleton (`actions.ts`'s `getOrCreateTooltipOverlay`):
+     * that one is `anchor-from="selection"` (tied to `ctx.selection`) and
+     * shared across every `show-tooltip` behavior a page authors (this
+     * page's own z-tooltip, for one) — reusing it here would fight over the
+     * same element on every hover. This one anchors at a plain, static
+     * `anchor="[lng,lat]"` instead, since a snap position has nothing to do
+     * with whatever `ctx.selection` currently holds.
+     */
+    private ensureSnapTipOverlay;
+    private handleSnapPoint;
     /** Harness map-point injection (spec: "Consumer Testing Surface") — the
      *  same path a real deck click/hover coordinate takes, so the om-map-point
      *  event and custom capture tools are testable without a GPU. */
@@ -285,6 +302,8 @@ export declare class OmMapElement extends HTMLElementBase {
     getLightingInternal(): LightingIR | null;
     /** Resolved terrain IR (headless test inspection) — null = no surface. */
     getTerrainInternal(): TerrainIR | null;
+    /** Resolved clip-box IR (headless test inspection) — null = no active box. */
+    getClipBoxInternal(): ClipBoxIR | null;
     /**
      * Canvas-only scene snapshot (spec: "Snapshot API") — basemap + deck
      * composited at device pixels. DOM widgets/overlays/badge/attribution are

package/dist/elements/om-overlay.d.ts

@@ -36,7 +36,19 @@ export declare class OmOverlayElement extends HTMLElementBase {
      * simply doesn't update this remembered anchor; only a matching
      * selection moves it, and only an explicit `visible="false"` hides it.
      */
+    /**
+     * A 3rd (z) component survives here specifically for the projection at
+     * the bottom of `updatePosition` — a selection's real elevation (a depth
+     * pick against terrain/3D content, see `Selection.coordinate`'s own doc
+     * comment) matters for WHERE on screen the anchor lands under a pitched
+     * camera, even though this class only ever positions in 2D. Dropping it
+     * (projecting at an implied z=0) put a tooltip over an elevated pick tens
+     * to hundreds of pixels from the actual cursor — the anchor was correct
+     * in lng/lat, just projected as if the picked surface were at sea level.
+     */
     private lastAnchor;
+    /** Cached [w, h] for `clip-to-map` (offsetWidth forces layout; flushes run per pointer move) — invalidated by setContent. */
+    private clipSizeCache;
     /** Memoized feature anchor — recomputed only when the layer's data reference or the target id changes (live layers swap data). */
     private featureAnchorCache;
     connectedCallback(): void;

package/dist/geodesy.d.ts

@@ -23,6 +23,22 @@ export type LngLat = [number, number];
 export declare function distanceMeters(a: LngLat, b: LngLat, radius?: number): number;
 /** Total haversine length of a polyline in meters (0 for < 2 points). */
 export declare function pathLengthMeters(points: LngLat[], radius?: number): number;
+export interface PathSample {
+    position: LngLat;
+    /** Cumulative distance (m) from the path's start. */
+    distance: number;
+}
+/**
+ * `count` evenly-spaced points along a multi-segment polyline, by cumulative
+ * distance (spec item E — elevation-profile samples). Walks the segment
+ * lengths to find which segment each target distance falls in, then
+ * `intermediate()`s within it — a straight generalization of that function
+ * from "interpolate one segment" to "interpolate a whole path." `count=1`
+ * returns just the start point; `points.length < 2` returns each input point
+ * at distance 0 (nothing to interpolate); a zero-length path (every point
+ * coincident) returns `count` copies of the start point at distance 0.
+ */
+export declare function resamplePath(points: LngLat[], count: number): PathSample[];
 /**
  * Spherical polygon area in m² via the Chamberlain–Duquette line integral (the
  * exact index form Turf's `ringArea` uses, so results match Turf's fixtures).
@@ -40,8 +56,18 @@ export declare function ringPerimeterMeters(ring: LngLat[], radius?: number): nu
  */
 export declare function ringEnclosesPole(ring: LngLat[]): boolean;
 /**
- * Great-circle midpoint of a segment — antimeridian-safe (converts to Cartesian
- * so a segment crossing ±180° gets its label on the shorter arc, not the middle
- * of the wrong way round). Returns [lng (normalized to (−180, 180]), lat].
+ * Point a `fraction` of the way from `a` to `b` along the great-circle path
+ * (spherical slerp) — spec item E's evenly-spaced elevation-profile samples
+ * need this; only the f=0.5 special case (`midpoint`) existed before.
+ * Antimeridian-safe (interpolates the Cartesian unit vectors, not lng/lat
+ * directly, so a segment crossing ±180° doesn't wrap the wrong way).
+ * `f=0` returns `a`, `f=1` returns `b`. Returns [lng (normalized to
+ * (−180, 180]), lat].
+ */
+export declare function intermediate(a: LngLat, b: LngLat, fraction: number): LngLat;
+/**
+ * Great-circle midpoint of a segment — `intermediate(a, b, 0.5)`, kept as its
+ * own name since "the point halfway along a segment" is the common case
+ * (badge label anchors) and reads better than a bare 0.5 at every call site.
  */
 export declare function midpoint(a: LngLat, b: LngLat): LngLat;

package/dist/{geoparquet-Dix4lTNy.js → geoparquet-DapHATA0.js}

@@ -1,4 +1,4 @@
-import { r as p, n as d } from "./index-1UgNlfGR.js";
+import { r as p, n as d } from "./index-7B-6Cbzu.js";
 function g(t) {
   if (t == null) return !0;
   const e = t, n = e.id?.code;

package/dist/html-data.d.ts

@@ -15,9 +15,9 @@ interface TagData {
     }[];
 }
 /** Hand-authored action list — validated against hasAction() in html-data.test.ts. */
-export declare const BUILTIN_ACTIONS: readonly ["toggle-layer", "zoom-in", "zoom-out", "filter-layer", "highlight-feature", "fade", "pulse", "populate", "trace", "story-play", "story-pause", "story-seek", "fly-to", "zoom-to-feature", "show-overlay", "hide-overlay", "show-tooltip", "hide-tooltip", "draw-mode", "draw-commit", "draw-cancel", "draw-delete", "draw-clear", "draw-config", "draw-save", "measure-mode", "measure-clear", "measure-units", "set-basemap", "set-lighting", "set-terrain", "set-widgets-visible", "undo", "redo"];
+export declare const BUILTIN_ACTIONS: readonly ["toggle-layer", "zoom-in", "zoom-out", "filter-layer", "highlight-feature", "fade", "pulse", "populate", "trace", "story-play", "story-pause", "story-seek", "fly-to", "zoom-to-feature", "show-overlay", "hide-overlay", "show-tooltip", "hide-tooltip", "draw-mode", "draw-commit", "draw-cancel", "draw-delete", "draw-clear", "draw-config", "draw-save", "export-region-3d", "measure-mode", "measure-clear", "measure-units", "set-basemap", "set-lighting", "set-terrain", "set-clip-box", "clip-box-edit", "set-widgets-visible", "undo", "redo"];
 /** Hand-authored widget types — validated against the widget registry in html-data.test.ts. */
-export declare const BUILTIN_WIDGETS: readonly ["legend", "layer-switcher", "zoom-controls", "scale-bar", "attribution", "filter", "vega-lite", "player", "draw", "measure", "basemap-switcher", "lighting", "undo-redo", "widgets-toggle", "ifc-browser", "ifc-legend", "feature-inspector", "ifc-inspector", "ifc-loader", "ifc-clash"];
+export declare const BUILTIN_WIDGETS: readonly ["legend", "layer-switcher", "zoom-controls", "scale-bar", "attribution", "filter", "vega-lite", "dynamic-chart", "player", "draw", "measure", "basemap-switcher", "lighting", "clip-box", "undo-redo", "widgets-toggle", "ifc-browser", "ifc-legend", "feature-inspector", "ifc-inspector", "ifc-loader", "ifc-clash"];
 export declare function buildHtmlCustomData(): {
     version: number;
     tags: TagData[];