@nika-js/onlymap 0.4.4 → 0.4.6

package/README.md

@@ -69,7 +69,7 @@ Or with no build step at all, straight from a CDN:
 
 The bare package URL serves `dist/onlymap.standalone.js`, a single-file bundle built for exactly this (jsDelivr too). Use a CDN that serves the package's raw files — **not** a rebundling CDN like esm.sh, which re-splits the bundle into duplicate copies of the deck.gl/luma.gl runtime and breaks every layer's shader compilation.
 
-Then `npx @nika-js/onlymap init` wires up VS Code IntelliSense and `!`-prefixed manifest snippets for your project. The library ships with 528 unit/behavioral tests and 45 Playwright GPU tests.
+Then `npx @nika-js/onlymap init` wires up VS Code IntelliSense and `!`-prefixed manifest snippets for your project. The library ships with 540 unit/behavioral tests and 53 Playwright GPU tests.
 
 The [examples](https://github.com/NikaGeospatial/onlymapjs/tree/main/examples) are the best tour: widgets, behaviors & overlays, basemaps, columnar/Arrow data, manual drawing, 3D models, scene lighting (with the native lighting widget), DEM terrain, a live WebSocket ship feed, and a polled driver fleet.
 
@@ -244,7 +244,9 @@ await h.pick({ layer: "quakes", featureId: "q1" }); // same code path as a real
 expect(overlay.shadowRoot.textContent).toContain("M 6.5");
 ```
 
-Plus `OmMap.snapshotIR(html)` to lock down what a manifest *means* in a snapshot test, and `await mapEl.ready` / the `om-map-ready` event to de-flake browser e2e tests. Full guide: [docs/testing.md](docs/testing.md).
+Plus `OmMap.snapshotIR(html)` to lock down what a manifest *means* in a snapshot test, and `await mapEl.ready` / the `om-map-ready` event to de-flake browser e2e tests.
+
+**Layout, checked like types.** `npx @nika-js/onlymap check-layout <manifest.html>` audits a page's real rendered widget layout in headless Chromium — no screenshots, no eyeballing: it asserts no widgets overlap, each is hit-testable (not painted under the canvas), each sits in its slot, and same-slot edges are flush, across a viewport-width sweep, emitting structured `{severity, element, message, fix}` diagnostics and exiting 0/1. The same audit is importable as `auditLayout(page)` for your own Playwright suite. Full guide: [docs/testing.md](docs/testing.md).
 
 ## 3D
 
@@ -254,8 +256,8 @@ Plus `OmMap.snapshotIR(html)` to lock down what a manifest *means* in a snapshot
 
 - **`OmMap.*`** — `validate`, `snapshotIR`, `registerLayer`, `registerWidget`, `registerAction`, `registerSource`, `registerFormat`, `registerBasemap`, `configureBasemap`, `configureData`, `configureTelemetry`, `configureLicense`, `getLayerSchema`
 - **`@nika-js/onlymap/deck`** — the bundled deck.gl classes (`CompositeLayer`, `TileLayer`, …) for building custom layer types: shims must extend the same class hierarchy the core renders with, not a second installed deck.gl copy. Recipe: [docs/custom-layers.md](docs/custom-layers.md)
-- **On a `<om-map>` element** — `ready` (promise), `flyTo(coords, zoom?)`, `setLayerVisible(id, bool)`, `getLayers()`, `emit(action, payload)`, `snapshot(opts?)` (canvas-only PNG of basemap + layers at device pixels — DOM widgets/overlays and provider attribution are NOT captured, so exports must render credits themselves; `{as: "blob"}` for files, default dataURL); the `om-view-changed` event fires once the camera settles (debounced; `detail` = `{longitude, latitude, zoom, pitch, bearing, origin}`, where `origin` is `"user"` for gesture-driven bursts vs `"programmatic"` for API/story moves — the echo-suppression signal for state sync) — the camera-persistence hook; `document.querySelector("om-map")` is fully typed
-- **`MapController`** — the framework-grade programmatic front-end (typed `LayerDescriptor`s → the same reconcile core, no DOM manifest): `setLayers`, `watch`, `emit`, camera methods, `injectPick`, `ready`, `snapshot`, an `onViewChange(view, origin)` option (the `om-view-changed` twin). The React adapter rides it; usable directly from vanilla TS or other frameworks
+- **On a `<om-map>` element** — `ready` (promise), `flyTo(coords, zoom?)`, `setLayerVisible(id, bool)`, `getLayers()`, `emit(action, payload)`, `snapshot(opts?)` (canvas-only PNG of basemap + layers at device pixels — DOM widgets/overlays and provider attribution are NOT captured, so exports must render credits themselves; `{as: "blob"}` for files, default dataURL); the `om-view-changed` event fires once the camera settles (debounced; `detail` = `{longitude, latitude, zoom, pitch, bearing, origin}`, where `origin` is `"user"` for gesture-driven bursts vs `"programmatic"` for API/story moves — the echo-suppression signal for state sync) — the camera-persistence hook; the `om-map-point` event (`detail = {coordinate: [lng,lat]|null, kind: "click"|"hover"}`) fires on every click/hover with the map coordinate, including empty-map clicks picks discard — the hook for custom capture tools the built-in draw widget doesn't cover; the `om-tileset-load` event (`detail = {layerId, tileset}`) surfaces a `Tile3DLayer`'s live deck `Tileset3D` for tools that need the real tileset (e.g. region export), not the IR; `document.querySelector("om-map")` is fully typed
+- **`MapController`** — the framework-grade programmatic front-end (typed `LayerDescriptor`s → the same reconcile core, no DOM manifest): `setLayers`, `watch`, `emit`, camera methods, `injectPick`, `ready`, `snapshot`, an `onViewChange(view, origin)` option (the `om-view-changed` twin), plus `onMapPoint` / `onTilesetLoad` options (the `om-map-point` / `om-tileset-load` twins). The React adapter rides it; usable directly from vanilla TS or other frameworks
 - **`getStore(token)`** — the external-store contract: per-token `{subscribe, getSnapshot}` stores (`viewport`/`selection`/`layers`/`data:<id>`) with cached immutable plain-data snapshots and `origin` tagging — directly consumable by `useSyncExternalStore` (the React adapter's own hooks ride it), MobX autoruns, Redux listeners, Zustand mirrors. ~20-line integration-tested recipes for Redux Toolkit, MobX/mobx-keystone, Zustand, and Jotai: [docs/external-stores.md](docs/external-stores.md)
 - **Testing** — `mountForTest`, and imports are SSR-safe (importing in Node/jsdom never touches browser globals)
 

package/bin/onlymapjs.mjs

@@ -137,8 +137,21 @@ async function checkLayout(manifestArg) {
     }
     const context = await browser.newContext({ serviceWorkers: "block" });
     const page = await context.newPage();
+    const pageErrors = [];
+    page.on("pageerror", (error) => pageErrors.push(String(error).split("\n")[0]));
+    page.on("console", (msg) => {
+      if (msg.type() === "error") pageErrors.push(msg.text().split("\n")[0]);
+    });
     await page.goto(url, { waitUntil: "domcontentloaded" });
-    const diagnostics = await auditLayout(page);
+    let diagnostics;
+    try {
+      diagnostics = await auditLayout(page);
+    } catch (error) {
+      // The page never produced a map. Its own console/pageerror output is the
+      // real cause — surface it so the failure is self-explaining.
+      const detail = pageErrors.length ? `\nPage errors:\n  ${pageErrors.slice(0, 3).join("\n  ")}` : "";
+      throw new Error(`${error instanceof Error ? error.message : String(error)}${detail}`);
+    }
     if (diagnostics.length === 0) {
       console.log("CLEAN: no widget layout problems at 360, 640, 768, or 1024px.");
       return 0;

package/dist/{LercDecode.es-CgN9Gb9e.js → LercDecode.es-B49qauXg.js}

@@ -19,7 +19,7 @@ async function v(N = {}) {
   if (n) {
     const { createRequire: I } = await import(
       /*webpackIgnore:true*/
-      "./lerc-l-QFh62d.js"
+      "./lerc-CaQOmDCP.js"
     ).then((g) => g._);
     var O = I(import.meta.url);
   }

package/dist/{basemap-Bfn5Z__c.js → basemap-nJ_ODY7r.js}

@@ -1,4 +1,4 @@
-import { C as ny, L as sy, M as oy, m as ay, c as ka, z as oc, a as Sd, G as sm, V as ly, W as cy, b as uy, g as hy, d as Vu, f as Ed, e as dy, l as py, u as fy, D as Qf, h as my } from "./index-KgO0MBqA.js";
+import { C as ny, L as sy, M as oy, m as ay, c as ka, z as oc, a as Sd, G as sm, V as ly, W as cy, b as uy, g as hy, d as Vu, f as Ed, e as dy, l as py, u as fy, D as Qf, h as my } from "./index-DSkgI4Oc.js";
 const Cd = Math.PI / 180, gy = 180 / Math.PI;
 function em(Pe, Q = 0) {
   const me = Math.min(180, Pe) * Cd;
@@ -25217,7 +25217,7 @@ class Ry {
    * remount, since `customAttribution` is fixed at construction.
    */
   mountAttribution(Q) {
-    if (this.showAttribution && (this.attributionText = Q, this.attribution && (this.map.removeControl(this.attribution), this.attributionElement = void 0), this.attribution = new rm.AttributionControl({ compact: !0, ...Q ? { customAttribution: Q } : {} }), this.map.addControl(this.attribution), this.attributionHost)) {
+    if (this.showAttribution && (this.attributionText = Q, this.attribution && (this.map.removeControl(this.attribution), this.attributionElement?.remove(), this.attributionElement = void 0), this.attribution = new rm.AttributionControl({ compact: !0, ...Q ? { customAttribution: Q } : {} }), this.map.addControl(this.attribution), this.attributionHost)) {
       const me = this.map.getContainer().querySelector(".maplibregl-ctrl-attrib");
       me && (me.setAttribute("data-om-mandated-chrome-item", "attribution"), me.style.margin = "0", this.attributionHost.appendChild(me), this.attributionElement = me);
     }
@@ -25272,7 +25272,7 @@ class Ry {
       for (const me of this.pendingCaptureRejects) me(Q);
       this.pendingCaptureRejects.clear();
     }
-    this.deckCaptures = [], this.attributionElement = void 0, this.overlay.finalize(), this.map.remove();
+    this.deckCaptures = [], this.attributionElement?.remove(), this.attributionElement = void 0, this.overlay.finalize(), this.map.remove();
   }
 }
 export {

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

@@ -67,6 +67,8 @@ export declare class OmMapElement extends HTMLElementBase {
     private widgetLayer;
     private readonly slotContainers;
     private readonly mandatedChromeHosts;
+    /** Slots that host mandated chrome (badge/attribution) — set at host creation, so the collision-dim exemption is a slot-level flag, not a per-flush DOM scan. */
+    private readonly slotsWithMandatedChrome;
     private widgetResizeObserver;
     private widgetsFolded;
     private foldPassPending;
@@ -99,13 +101,22 @@ export declare class OmMapElement extends HTMLElementBase {
      * adapters mount/unmount the actual controls inside.
      */
     private ensureMandatedChromeHost;
+    /** True while an internal reparent (slotting/manual-flip) is moving a widget — its transient disconnect must NOT be read as an author removal. */
+    private inSlotReparent;
+    /** Wrap an internal reparent: suppress history AND flag it as a move so unregisterWidgetInternal keeps the fold/anchor bookkeeping. */
+    private reparent;
     slotWidgetInternal(el: HTMLElement, slot: WidgetSlot): void;
     /** Called by <om-widget> when its live `fold` attribute changes. */
     refreshWidgetFoldInternal(): void;
     private startWidgetFoldObserver;
+    private foldBreakpointRaw?;
+    private foldBreakpointCache;
+    /** Cached breakpoint resolution — re-probes only when the token string actually changes, not on every ResizeObserver tick. */
     private foldBreakpointPx;
     private measureWidgetFold;
     private updateWidgetFoldForWidth;
+    /** Lift the bottom-end row clear of the bottom drawer toggle while folded. Applied here AND in the fold pass so a lazily-created bottom-end container still gets it. */
+    private syncFoldBottomOffset;
     private scheduleFoldPass;
     private shouldFoldWidget;
     private ensureFoldDrawer;
@@ -172,6 +183,7 @@ export declare class OmMapElement extends HTMLElementBase {
      * modeled (headless has no rects; this no-ops there).
      */
     private dimSlotsAgainstOverlays;
+    /** widgets-toggle can sit in any author-chosen slot, so still scan for it (attribution/badge are covered by the slot flag). */
     private slotHasNeverHidesWidget;
     emit(event: string, payload?: Record<string, unknown>): void;
     /** Recenters (and optionally rezooms) the map — instant, not an animated fly. */
@@ -218,6 +230,20 @@ export declare class OmMapElement extends HTMLElementBase {
      */
     injectPickInternal(selection: Selection | null): void;
     injectDragPickInternal(selection: Selection): void;
+    /** Every click/hover map coordinate (spec: "Manual Drawing"): drives the
+     *  internal draw controller AND fires the public `om-map-point` event, so
+     *  consumer capture tools the built-in draw widget doesn't cover
+     *  (rectangle/circle AOIs) can subscribe. The two consumers are
+     *  DECOUPLED: the event dispatches first (dispatchEvent isolates a
+     *  throwing listener), then the draw controller runs — so neither a
+     *  throwing draw session nor a throwing listener can starve the other.
+     *  Fires at pointer rate on hover (no debounce — vertex capture needs
+     *  every point); heavy listeners should throttle their own work. */
+    private handleMapPoint;
+    /** 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. */
+    injectMapPointInternal(coordinate: [number, number] | null, kind?: "click" | "hover"): void;
     /** Harness setView (spec: "Consumer Testing Surface") — the one path that reaches pitch/bearing. */
     setViewInternal(partial: {
         longitude?: number;
@@ -302,6 +328,20 @@ declare global {
             /** "user" if any change in the settled burst came from a canvas gesture; "programmatic" for pure API/action/story moves. */
             origin: "user" | "programmatic";
         }>;
+        /** Every click/hover's map coordinate (null when the pointer is off any
+         *  geometry deck can unproject) — the consumer hook for custom capture
+         *  tools beyond the built-in draw widget. */
+        "om-map-point": CustomEvent<{
+            coordinate: [number, number] | null;
+            kind: "click" | "hover";
+        }>;
+        /** A Tile3DLayer finished loading its root tileset — detail carries the
+         *  authored layer id and the live deck `Tileset3D` for tools (e.g. region
+         *  export) that need the real tileset, not the IR. */
+        "om-tileset-load": CustomEvent<{
+            layerId: string;
+            tileset: unknown;
+        }>;
     }
 }
 export {};

package/dist/{index-CnitG1VX.js → index-CeOjfL2p.js}

@@ -1,5 +1,5 @@
-import { i as E, j as S, k as R, n as N, o as h, p as w, q as O, s as W, r as x, t as I, v as B, w as _, x as P, y as k, A as $, B as z, E as v, F, H as C, I as U, J as p, K as M } from "./index-KgO0MBqA.js";
-import { N as $e, R as ze, _ as ve, O as Ce, P as Ue, Q as Me, S as je, T as De, U as Je, X as qe, Y as He, Z as Ve, $ as Ge, a0 as Ke, a1 as Qe, a2 as Xe, a3 as Ye, a4 as Ze, a5 as et, a6 as tt, a7 as nt, a8 as rt, a9 as at, aa as st, ab as ot } from "./index-KgO0MBqA.js";
+import { i as E, j as S, k as R, n as N, o as h, p as w, q as O, s as W, r as x, t as I, v as B, w as _, x as P, y as k, A as $, B as z, E as v, F, H as C, I as U, J as p, K as M } from "./index-DSkgI4Oc.js";
+import { N as $e, R as ze, _ as ve, O as Ce, P as Ue, Q as Me, S as je, T as De, U as Je, X as qe, Y as He, Z as Ve, $ as Ge, a0 as Ke, a1 as Qe, a2 as Xe, a3 as Ye, a4 as Ze, a5 as et, a6 as tt, a7 as nt, a8 as rt, a9 as at, aa as st, ab as ot } from "./index-DSkgI4Oc.js";
 import { g as j, i as D } from "./table-accessors-CYWTzpQI.js";
 async function J(t, e, n = {}, r = {}) {
   const a = E(t), s = S.getWorkerFarm(n), { source: o } = n, c = { name: a, source: o };