@nika-js/onlymap 0.4.3 → 0.4.6

package/dist/basemap.d.ts

@@ -22,8 +22,10 @@ export declare class MapLibreBasemapAdapter {
     private overlay;
     /** Our own compact attribution control (spec: "attribution becomes correct, not optional") — undefined when the author opted out. */
     private attribution?;
+    private attributionElement?;
     private attributionText?;
     private showAttribution;
+    private attributionHost?;
     /**
      * One-time "has the map initialized at least once" flag, set by the first
      * `load` event. Deliberately NOT `this.map.loaded()` — that method means
@@ -46,7 +48,7 @@ export declare class MapLibreBasemapAdapter {
         zoom: number;
         pitch?: number;
         bearing?: number;
-    }, deckProps: DeckProps, showAttribution?: boolean);
+    }, deckProps: DeckProps, showAttribution?: boolean, attributionHost?: HTMLElement);
     /** Snapshot capture queue for the overlay's deck canvas — see captureComposite. */
     private deckCaptures;
     /** In-flight captureComposite rejects — destroy() settles them so a caller never hangs on a torn-down renderer. */

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

@@ -66,6 +66,16 @@ export declare class OmMapElement extends HTMLElementBase {
     /** Library-owned stacking layer: one absolutely-positioned flex container per managed slot, created lazily. Rendering plumbing, never authored state. */
     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;
+    private inFoldPass;
+    private readonly foldMapId;
+    private readonly foldedWidgetSlots;
+    private readonly foldDrawers;
     /**
      * Is this node layout plumbing (the widget layer, slot containers, or
      * cluster wrappers)? Their childList churn is rendering, not manifest
@@ -84,7 +94,36 @@ export declare class OmMapElement extends HTMLElementBase {
     private readonly slotAnchors;
     /** The widget layer div — lazy, shared by slot containers AND the layout tokens (both lanes put tokens on the layer, never on an authored element). */
     private ensureWidgetLayer;
+    private ensureSlotContainer;
+    /**
+     * Provider attribution and the free-license badge are immutable members of
+     * managed slots. Their stable wrappers stay front-end-owned while renderer
+     * 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;
+    private setFoldDrawerOpen;
+    private focusFirstIn;
+    private restoreFoldedWidget;
+    private runFoldPass;
     private clusterPassPending;
     /** Re-entry guard: the pass's own reparenting fires connect callbacks that call back into scheduleClusterPass — self-inflicted, never re-schedule. */
     private inClusterPass;
@@ -144,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. */
@@ -190,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;
@@ -274,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-BPKvpqIk.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-DzyVbu_T.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-DzyVbu_T.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 };