@nika-js/onlymap 0.4.2 → 0.4.4

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

@@ -28,6 +28,15 @@ import type { Selection } from "../selection";
 import type { MapViewport } from "../basemap";
 interface OverlayHost {
     updatePosition(viewport: MapViewport | undefined, selection: Selection | null): void;
+    /**
+     * Screen rect for collision-dim (spec: "Overlap avoidance") — non-null
+     * only when the overlay is VISIBLE and participates in dimming. Returns
+     * null when hidden OR when it's transient runtime chrome (the internal
+     * hover tooltip / trace / draw preview): those glide constantly and must
+     * not flicker widgets. The map reads this off its registered host set
+     * rather than re-querying the DOM.
+     */
+    getVisibleRect(): DOMRect | null;
 }
 export declare class OmMapElement extends HTMLElementBase {
     private core;
@@ -57,6 +66,14 @@ 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;
+    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
@@ -75,7 +92,27 @@ 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;
     slotWidgetInternal(el: HTMLElement, slot: WidgetSlot): void;
+    /** Called by <om-widget> when its live `fold` attribute changes. */
+    refreshWidgetFoldInternal(): void;
+    private startWidgetFoldObserver;
+    private foldBreakpointPx;
+    private measureWidgetFold;
+    private updateWidgetFoldForWidth;
+    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;
@@ -125,6 +162,17 @@ export declare class OmMapElement extends HTMLElementBase {
      * multiple viewport/selection changes per frame into one DOM pass).
      */
     private scheduleOverlayFlush;
+    /**
+     * Dynamic overlap avoidance (spec: "Widget Layout Manager / Overlap
+     * avoidance") — a slot container whose rect intersects an OPEN
+     * `<om-overlay>` popup is dimmed (`--om-widget-opacity-dimmed`, default
+     * 0.35) rather than repositioned. Own overlays only (issue Q1: foreign
+     * absolutely-positioned DOM is unknowable). `widgets-dim="off"` opts out.
+     * Real-geometry only — verified behaviorally in the layout audit, never
+     * modeled (headless has no rects; this no-ops there).
+     */
+    private dimSlotsAgainstOverlays;
+    private slotHasNeverHidesWidget;
     emit(event: string, payload?: Record<string, unknown>): void;
     /** Recenters (and optionally rezooms) the map — instant, not an animated fly. */
     flyTo(coords: [number, number], zoom?: number, opts?: {

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

@@ -78,5 +78,13 @@ export declare class OmOverlayElement extends HTMLElementBase {
      * static `anchor="[lng,lat]"`), culls off-screen/behind-camera anchors,
      * and re-interpolates `{{field}}` tokens against the current selection.
      */
+    /**
+     * Screen rect for collision-dim (spec: "Overlap avoidance") — null when
+     * hidden (via COMPUTED visibility, so author CSS/class hiding counts too,
+     * not just our inline write) or when this is transient runtime chrome
+     * (`__onlymapjs-` tooltip/trace/draw preview, which glides on hover and
+     * must not flicker widgets). Only stable author popups drive dimming.
+     */
+    getVisibleRect(): DOMRect | null;
     updatePosition(viewport: MapViewport | undefined, selection: Selection | null): void;
 }

package/dist/{index-CeAQFyJG.js → index-C4cWRigY.js}

@@ -1,4 +1,4 @@
-import { ai as Bt, ak as Xt, al as Yt, am as Us } from "./index-ULsb51al.js";
+import { ai as Bt, ak as Xt, al as Yt, am as Us } from "./index-KgO0MBqA.js";
 import { w as gs, t as Hs, f as Ws, m as Qs } from "./mgrs-BY9bIvp4.js";
 import { c as Xs } from "./convert-arrow-schema-DrAihRf9.js";
 import { y as Ys, A as bt, a as Ks, z as Vs, R as Zs } from "./recordbatch-Bpc0uxFn.js";

package/dist/{index-CU-Ft1NI.js → index-CnitG1VX.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-ULsb51al.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-ULsb51al.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-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 { 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 };