@nika-js/onlymap 0.1.1 → 0.2.0

package/dist/programmatic.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Programmatic front-end (spec: HU2 — "one core, two front-ends"). Builds
+ * the SAME layer IR the DOM manifest front-end (parse-manifest.ts) produces
+ * — from typed descriptors instead of <om-layer> elements, with no DOM
+ * manifest in between — and drives the same RuntimeCore reconcile.
+ * Frameworks ride this front-end (the React adapter, src/react/), so the
+ * DOM-ownership collision (a framework re-asserting its virtual DOM vs.
+ * this library's MutationObserver) never arises: there is nothing shared
+ * to fight over.
+ *
+ * What deliberately does NOT exist here: behaviors, <script type="om/widget">
+ * blocks, manifest validation, stories, and the draw widget — those are
+ * DOM/HTML-native authoring surfaces. A framework expresses the same intent
+ * through its own event handlers and state (spec: HU2 "the catch"), reading
+ * runtime state through the same RuntimeContext contract widgets get (HU5).
+ */
+import { type CameraOptions } from "./runtime-core";
+import type { LayerIR } from "./ir";
+import { type RuntimeContext } from "./ctx";
+import type { Selection } from "./selection";
+import type { ValidationEntry } from "./validation";
+import type { MapViewport } from "./basemap";
+/**
+ * A layer, declared as a typed value — the programmatic mirror of one
+ * <om-layer> element. Accessors are plain JS functions (no expression
+ * language, no trust step — first-party code is trusted by definition).
+ */
+export interface LayerDescriptor {
+    /** Stable identity — same contract as the `id` attribute. Required. */
+    id: string;
+    /** deck.gl layer class name, e.g. "ScatterplotLayer". */
+    type: string;
+    /**
+     * Inline rows / GeoJSON / columnar data passed by reference, or a URL
+     * string — URLs ride the Data Layer exactly like the `data` attribute
+     * (format detection, ws(s):// streams, `refresh` polling, draw: stores).
+     * Keep inline references STABLE across commits (memoize in the caller):
+     * the `data:<id>` watch tokens diff by reference.
+     */
+    data?: unknown;
+    /** Legend metadata (ctx.layers), same as the label/color attributes. */
+    label?: string;
+    color?: string;
+    /** GPU filter (spec: "Filtering") — mirrors filter-field/filter-range/… */
+    filterField?: string;
+    filterRange?: [number, number];
+    filterSoftRange?: [number, number];
+    filterCategoryField?: string;
+    filterCategories?: unknown[];
+    /** Stream options for ws(s):// data URLs (spec: "Live & Streaming Data"). */
+    source?: string;
+    key?: string;
+    flush?: string;
+    /** Polling interval for REST snapshot URLs, e.g. "5s". */
+    refresh?: string;
+    /**
+     * deck.gl updateTriggers, passed through per accessor prop. deck ignores
+     * accessor FUNCTION identity by design — supply a value here that changes
+     * when an accessor's output changes (the deck-idiomatic contract).
+     */
+    updateTriggers?: Record<string, unknown>;
+    /** deck.gl props (camelCase), accessors as plain functions — passed through. */
+    props?: Record<string, unknown>;
+}
+/** Camera state, both an input (options/setView) and an output (getViewState). */
+export interface CameraState {
+    longitude: number;
+    latitude: number;
+    zoom: number;
+    pitch: number;
+    bearing: number;
+}
+export interface MapControllerOptions {
+    center?: [number, number];
+    zoom?: number;
+    pitch?: number;
+    bearing?: number;
+    /** Same contract as the `basemap` attribute — "maplibre", a style URL, or omit for standalone deck.gl. */
+    basemap?: string;
+    /** Headless mode (spec: "Consumer Testing Surface") — no renderer, real projection math; for jsdom/happy-dom tests. */
+    headless?: {
+        width?: number;
+        height?: number;
+    };
+    /** Runtime error boundary — deck.gl-level failures in the structured validation shape. */
+    onRuntimeError?: (entry: ValidationEntry) => void;
+}
+/** Descriptor → layer IR: the programmatic counterpart of one parse-manifest.ts loop iteration. */
+export declare function descriptorToIR(desc: LayerDescriptor, onDataLoaded: () => void): LayerIR | null;
+/** rAF-batched overlay positioning hook — same flush contract as the DOM front-end's OverlayHost. */
+export type OverlayPositioner = (viewport: MapViewport | undefined, selection: Selection | null) => void;
+/**
+ * Pick stream for framework event handlers. `null` means the pointer left
+ * whatever it was hovering (deck reports an empty pick) — the "hover out"
+ * signal; clicks never arrive as null.
+ */
+export type PickListener = (selection: Selection | null) => void;
+/**
+ * The programmatic map instance — owns a RuntimeCore plus the same
+ * orchestration OmMapElement provides around it (layer IR registry, watch
+ * pub-sub, selection normalization, overlay flush, readiness), minus every
+ * DOM-manifest concern. One controller per map container.
+ */
+export declare class MapController {
+    private core;
+    private mount;
+    private layerIRs;
+    private descriptors;
+    private selection;
+    private watchers;
+    private pickListeners;
+    private overlayFns;
+    private overlayFlushPending;
+    private commitPending;
+    private destroyed;
+    private firstCommitDone;
+    private readyFired;
+    private resolveReady;
+    readonly ready: Promise<void>;
+    constructor(container: HTMLElement, options?: MapControllerOptions);
+    /** Replaces the full layer set (z-order = array order) — descriptors are re-resolved on a microtask-coalesced commit. */
+    setLayers(descriptors: readonly LayerDescriptor[]): void;
+    /** A snapshot of the current layer IRs — the same shape ctx.layers is built from. */
+    getLayers(): readonly LayerIR[];
+    private scheduleCommit;
+    private commit;
+    private checkReady;
+    /** Readiness as a poll (the promise form is `ready`). */
+    isReady(): boolean;
+    /**
+     * Subscribes to watch tokens ("viewport", "selection", "layers",
+     * "data:<layerId>") — `notify` runs immediately with the current context
+     * (initial render parity with widget registration), then on every matching
+     * change. Returns the unsubscribe function.
+     */
+    watch(tokens: readonly string[], notify: (ctx: RuntimeContext) => void): () => void;
+    private notifyWatchers;
+    /** The RuntimeContext contract (HU5) — identical to what HTML widget scripts receive as `ctx`. */
+    buildCtx(): RuntimeContext;
+    /** Picked object, normalized to flat — same path as OmMapElement (GeoJSON properties lifted; columnar rows materialized). */
+    private resolvePickedObject;
+    private handleSelectionChange;
+    getSelection(): Selection | null;
+    /** Every hover/click pick (null = hover left) — the stream framework adapters route to per-layer onClick/onHover handlers. */
+    watchPicks(listener: PickListener): () => void;
+    /**
+     * Synthetic pick injection (spec: "Consumer Testing Surface") — lands on
+     * the SAME selection path real deck.gl picks arrive through, so
+     * flattening, watcher notification, and overlay flush are same-path by
+     * construction.
+     */
+    injectPick(selection: Selection | null): void;
+    /**
+     * Registers an rAF-batched positioner: called with the fresh viewport +
+     * selection whenever either may have moved (spec: "Overlay Renderer" —
+     * one flush per frame across all overlays). Returns unsubscribe.
+     */
+    registerOverlay(positioner: OverlayPositioner): () => void;
+    /**
+     * Requests a re-flush of every registered positioner — for state changes
+     * a positioner reads from OUTSIDE the flush arguments (framework props
+     * like anchor/visible), which the controller can't observe itself.
+     * rAF-coalesced, so calling it eagerly is free.
+     */
+    refreshOverlays(): void;
+    private scheduleOverlayFlush;
+    /** Dispatches an action (spec: "Action payload contract") — camera moves, pulse/populate effects, custom registered actions. */
+    emit(event: string, payload?: Record<string, unknown>): void;
+    flyTo(center: [number, number], zoom?: number, opts?: CameraOptions): void;
+    flyToBounds(bounds: [[number, number], [number, number]], padding?: number, opts?: CameraOptions): void;
+    setView(partial: Partial<CameraState>, opts?: CameraOptions): void;
+    getViewState(): CameraState;
+    /** Projects a lng/lat through the current viewport — undefined before the viewport resolves. */
+    project(lngLat: [number, number]): [number, number] | undefined;
+    destroy(): void;
+}

package/dist/react/context.d.ts

@@ -0,0 +1,25 @@
+import type { MapController, LayerDescriptor } from "@nika-js/onlymap";
+export type WidgetPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+export interface OmMapContextValue {
+    controller: MapController;
+    layers: LayerRegistry;
+    /** The pane <OmOverlay> portals into — absolutely positioned above the canvas, pointer-events: none. */
+    overlayPane: HTMLDivElement;
+    /** Corner containers <OmWidget> portals into (filled as OmMap's own DOM mounts). */
+    corners: Readonly<Record<WidgetPosition, HTMLDivElement | null>>;
+}
+export declare const OmMapContext: import("react").Context<OmMapContextValue | null>;
+export declare function useOmMapContext(caller: string): OmMapContextValue;
+/**
+ * Mount-ordered descriptor registry: one entry per <OmLayer>, insertion
+ * order = mount order = deck.gl z-order. Every change hands the full set to
+ * MapController.setLayers, which microtask-coalesces commits — N layer
+ * updates in one render pass cost one reconcile.
+ */
+export declare class LayerRegistry {
+    private controller;
+    private descriptors;
+    constructor(controller: MapController);
+    upsert(descriptor: LayerDescriptor): void;
+    remove(id: string): void;
+}

package/dist/react/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @nika-js/onlymap/react — the React adapter (spec: HU2/HU5/HU7).
+ *
+ * Rides the core's programmatic front-end: components build typed layer
+ * descriptors → the same IR → the same reconcile core as the HTML manifest.
+ * React never renders <om-*> elements, so React's DOM ownership and the
+ * core's MutationObserver never meet. React is a peer dependency of this
+ * entry only — importing the core package alone never loads it.
+ */
+export { OmMap } from "./om-map";
+export type { OmMapProps, OmMapHandle } from "./om-map";
+export { OmLayer } from "./om-layer";
+export type { OmLayerProps } from "./om-layer";
+export { OmWidget } from "./om-widget";
+export type { OmWidgetProps } from "./om-widget";
+export { OmOverlay } from "./om-overlay";
+export type { OmOverlayProps, AnchorOffset } from "./om-overlay";
+export { useOmMap } from "./use-om-map";
+export type { WidgetPosition } from "./context";
+export type { RuntimeContext, Selection, LayerDescriptor, CameraState, MapController } from "@nika-js/onlymap";

package/dist/react/om-layer.d.ts

@@ -0,0 +1,38 @@
+import type { Selection } from "@nika-js/onlymap";
+export interface OmLayerProps {
+    /** Stable identity — same contract as the `id` attribute. */
+    id: string;
+    /** deck.gl layer class name, e.g. "ScatterplotLayer". */
+    type: string;
+    /**
+     * Inline rows / GeoJSON / columnar data, or a URL string (formats,
+     * ws(s):// streams, `refresh` polling — the full Data Layer). Keep inline
+     * references stable across renders (useMemo/useState): `data:<id>` watch
+     * tokens diff by reference.
+     */
+    data?: unknown;
+    /** Legend metadata (ctx.layers). */
+    label?: string;
+    color?: string;
+    /** GPU filter (DataFilterExtension) — mirrors filter-field/filter-range. */
+    filterField?: string;
+    filterRange?: [number, number];
+    filterSoftRange?: [number, number];
+    filterCategoryField?: string;
+    filterCategories?: unknown[];
+    /** Stream options for ws(s):// data URLs. `streamKey` is the upsert identity field (the `key` attribute — `key` itself is reserved by React). */
+    source?: string;
+    streamKey?: string;
+    flush?: string;
+    /** Polling interval for REST snapshot URLs, e.g. "5s". */
+    refresh?: string;
+    /** deck.gl updateTriggers — supply a changing value when an accessor's OUTPUT changes (deck ignores function identity). */
+    updateTriggers?: Record<string, unknown>;
+    /** Click pick on this layer (object flattened/materialized, same as ctx.selection). */
+    onClick?: (selection: Selection) => void;
+    /** Hover pick on this layer; `null` = the pointer left whatever it was hovering. */
+    onHover?: (selection: Selection | null) => void;
+    /** Everything else passes through as deck.gl props (camelCase): getPosition, radiusMinPixels, visible, opacity, pickable, … */
+    [deckProp: string]: unknown;
+}
+export declare function OmLayer(props: OmLayerProps): null;

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

@@ -0,0 +1,29 @@
+import type { CSSProperties, ReactNode } from "react";
+import { MapController } from "@nika-js/onlymap";
+import type { CameraState, ValidationEntry } from "@nika-js/onlymap";
+export interface OmMapProps {
+    /** Initial camera — later prop changes move the camera (instant; use a ref + flyTo for animated moves). */
+    center?: [number, number];
+    zoom?: number;
+    pitch?: number;
+    bearing?: number;
+    /** Same contract as the `basemap` attribute — "maplibre", a style URL, or omit for standalone deck.gl. Changing it remounts the renderer. */
+    basemap?: string;
+    /** Headless mode for tests (spec: "Consumer Testing Surface") — no renderer, real projection math under jsdom/happy-dom. */
+    headless?: boolean | {
+        width?: number;
+        height?: number;
+    };
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+    /** Fired once: renderer initialized + first commit ran + no declared data URL still loading (the `.ready` contract). */
+    onReady?: () => void;
+    /** Fired on every camera change (pan/zoom/pitch/bearing). */
+    onViewStateChange?: (view: CameraState) => void;
+    /** Runtime error boundary — deck.gl-level failures in the structured validation shape. */
+    onRuntimeError?: (entry: ValidationEntry) => void;
+}
+/** The imperative surface (`ref`) — the MapController itself: flyTo, setView, emit, getLayers, injectPick, ready. */
+export type OmMapHandle = MapController;
+export declare const OmMap: import("react").ForwardRefExoticComponent<OmMapProps & import("react").RefAttributes<MapController>>;

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

@@ -0,0 +1,27 @@
+import type { CSSProperties, ReactNode } from "react";
+import type { Selection } from "@nika-js/onlymap";
+export type AnchorOffset = "top-left" | "top-center" | "top-right" | "center-left" | "center" | "center-right" | "bottom-left" | "bottom-center" | "bottom-right";
+export interface OmOverlayProps {
+    /** Static anchor [lng, lat]. */
+    anchor?: [number, number];
+    /** Dynamic anchor: follow the current selection (click/hover picks). */
+    anchorFrom?: "selection";
+    /** Scope a selection-anchored overlay to one layer's picks — non-matching selections don't move or re-render it. */
+    layer?: string;
+    visible?: boolean;
+    /** Attachment point relative to the anchor (default bottom-center: content sits above the point). */
+    anchorOffset?: AnchorOffset;
+    /**
+     * Set false for hover-following content (tooltips): a hoverable overlay
+     * sits over the picked point and would steal the pointer from the canvas,
+     * flickering the pick on/off (same rationale as the HTML overlay's
+     * automatic pointer-events handling — explicit here since JSX
+     * interactivity isn't detectable).
+     */
+    interactive?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    /** Static JSX, or a function of the tracked selection (spec: HU7's `{sel => <QuakeCard feature={sel.object} />}`). */
+    children?: ReactNode | ((selection: Selection | null) => ReactNode);
+}
+export declare function OmOverlay(props: OmOverlayProps): ReactNode;

package/dist/react/om-widget.d.ts

@@ -0,0 +1,9 @@
+import type { CSSProperties, ReactNode } from "react";
+import { type WidgetPosition } from "./context";
+export interface OmWidgetProps {
+    position?: WidgetPosition;
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+}
+export declare function OmWidget({ position, className, style, children }: OmWidgetProps): ReactNode;

package/dist/react/use-om-map.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeContext } from "@nika-js/onlymap";
+export declare function useOmMap(watch?: readonly string[]): RuntimeContext;

package/dist/react.js

@@ -0,0 +1,272 @@
+var q = Object.defineProperty;
+var H = (e, t, n) => t in e ? q(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var D = (e, t, n) => H(e, typeof t != "symbol" ? t + "" : t, n);
+import { jsxs as G, jsx as w } from "react/jsx-runtime";
+import { createContext as J, useContext as B, forwardRef as Q, useRef as d, useState as p, useCallback as U, useMemo as j, useLayoutEffect as X, useImperativeHandle as Y, useEffect as O } from "react";
+import { MapController as Z } from "@nika-js/onlymap";
+import { createPortal as $ } from "react-dom";
+const A = J(null);
+function F(e) {
+  const t = B(A);
+  if (!t) throw new Error(`[onlymapjs] ${e} must be rendered inside <OmMap>.`);
+  return t;
+}
+function L(e, t) {
+  if (e === t) return !0;
+  const n = Object.keys(e ?? {}), r = Object.keys(t ?? {});
+  return n.length !== r.length ? !1 : n.every((l) => e[l] === t[l]);
+}
+function ee(e, t) {
+  const { props: n, updateTriggers: r, ...l } = e, { props: a, updateTriggers: u, ...c } = t;
+  return L(l, c) && L(n, a) && L(r, u);
+}
+class te {
+  constructor(t) {
+    D(this, "descriptors", /* @__PURE__ */ new Map());
+    this.controller = t;
+  }
+  upsert(t) {
+    const n = this.descriptors.get(t.id);
+    n && ee(n, t) || (this.descriptors.set(t.id, t), this.controller.setLayers([...this.descriptors.values()]));
+  }
+  remove(t) {
+    this.descriptors.delete(t) && this.controller.setLayers([...this.descriptors.values()]);
+  }
+}
+const _ = ["top-left", "top-right", "bottom-left", "bottom-right"];
+function re(e) {
+  return {
+    position: "absolute",
+    [e.startsWith("top") ? "top" : "bottom"]: 10,
+    [e.endsWith("left") ? "left" : "right"]: 10,
+    display: "flex",
+    flexDirection: "column",
+    gap: 8,
+    alignItems: e.endsWith("left") ? "flex-start" : "flex-end",
+    zIndex: 20,
+    // The container never intercepts the map's pointer events; each
+    // <OmWidget> shell re-enables its own.
+    pointerEvents: "none"
+  };
+}
+function ne(e, t) {
+  return Object.entries(t).some(([n, r]) => r !== void 0 && e[n] !== r);
+}
+const fe = Q(function(t, n) {
+  const { center: r, zoom: l, pitch: a, bearing: u, basemap: c, headless: i, className: y, style: x, children: C } = t, E = d(null), [s, f] = p(null), [h, I] = p(null), [P, k] = p({
+    "top-left": null,
+    "top-right": null,
+    "bottom-left": null,
+    "bottom-right": null
+  }), z = U((o) => {
+    I((m) => m === o ? m : o);
+  }, []), K = j(
+    () => Object.fromEntries(
+      _.map((o) => [
+        o,
+        (m) => {
+          k((R) => R[o] === m ? R : { ...R, [o]: m });
+        }
+      ])
+    ),
+    []
+  ), g = d({ center: r, zoom: l, pitch: a, bearing: u });
+  g.current = { center: r, zoom: l, pitch: a, bearing: u };
+  const v = d(t.onReady);
+  v.current = t.onReady;
+  const b = d(t.onViewStateChange);
+  b.current = t.onViewStateChange;
+  const S = d(t.onRuntimeError);
+  S.current = t.onRuntimeError;
+  const N = i ? JSON.stringify(i) : "";
+  X(() => {
+    if (!E.current) return;
+    const o = g.current, m = new Z(E.current, {
+      center: o.center,
+      zoom: o.zoom,
+      pitch: o.pitch,
+      bearing: o.bearing,
+      basemap: c,
+      headless: i ? i === !0 ? {} : i : void 0,
+      onRuntimeError: (M) => {
+        var W;
+        return (W = S.current) == null ? void 0 : W.call(S, M);
+      }
+    });
+    f(m);
+    let R = !0;
+    return m.ready.then(() => {
+      var M;
+      R && ((M = v.current) == null || M.call(v));
+    }), () => {
+      R = !1, f(null), m.destroy();
+    };
+  }, [c, N]), Y(n, () => s, [s]), O(() => {
+    if (!s) return;
+    const o = { longitude: r == null ? void 0 : r[0], latitude: r == null ? void 0 : r[1], zoom: l, pitch: a, bearing: u };
+    ne(s.getViewState(), o) && s.setView(o);
+  }, [s, r == null ? void 0 : r[0], r == null ? void 0 : r[1], l, a, u]), O(() => {
+    if (s)
+      return s.watch(["viewport"], () => {
+        var o;
+        return (o = b.current) == null ? void 0 : o.call(b, s.getViewState());
+      });
+  }, [s]);
+  const T = j(() => s ? new te(s) : null, [s]), V = j(
+    () => s && T && h ? { controller: s, layers: T, overlayPane: h, corners: P } : null,
+    [s, T, h, P]
+  );
+  return /* @__PURE__ */ G("div", { className: y, style: { position: "relative", overflow: "hidden", ...x }, children: [
+    /* @__PURE__ */ w("div", { ref: E, style: { position: "absolute", inset: 0 } }),
+    /* @__PURE__ */ w(
+      "div",
+      {
+        ref: z,
+        style: { position: "absolute", top: 0, left: 0, zIndex: 10, pointerEvents: "none" }
+      }
+    ),
+    _.map((o) => /* @__PURE__ */ w(
+      "div",
+      {
+        "data-om-widget-corner": o,
+        ref: K[o],
+        style: re(o)
+      },
+      o
+    )),
+    V && /* @__PURE__ */ w(A.Provider, { value: V, children: C })
+  ] });
+}), oe = /* @__PURE__ */ new Set([
+  "id",
+  "type",
+  "data",
+  "label",
+  "color",
+  "filterField",
+  "filterRange",
+  "filterSoftRange",
+  "filterCategoryField",
+  "filterCategories",
+  "source",
+  "streamKey",
+  "flush",
+  "refresh",
+  "updateTriggers",
+  "onClick",
+  "onHover"
+]);
+function de(e) {
+  const { controller: t, layers: n } = F("OmLayer"), { id: r } = e, l = {};
+  for (const [i, y] of Object.entries(e))
+    !oe.has(i) && y !== void 0 && (l[i] = y);
+  const a = {
+    id: r,
+    type: e.type,
+    data: e.data,
+    label: e.label,
+    color: e.color,
+    filterField: e.filterField,
+    filterRange: e.filterRange,
+    filterSoftRange: e.filterSoftRange,
+    filterCategoryField: e.filterCategoryField,
+    filterCategories: e.filterCategories,
+    source: e.source,
+    key: e.streamKey,
+    flush: e.flush,
+    refresh: e.refresh,
+    updateTriggers: e.updateTriggers,
+    props: l
+  };
+  O(() => {
+    n.upsert(a);
+  }), O(() => () => n.remove(r), [n, r]);
+  const u = d(e.onClick);
+  u.current = e.onClick;
+  const c = d(e.onHover);
+  return c.current = e.onHover, O(
+    () => t.watchPicks((i) => {
+      var y, x, C;
+      if (i === null) {
+        (y = c.current) == null || y.call(c, null);
+        return;
+      }
+      i.layerId === r && (i.type === "click" ? (x = u.current) == null || x.call(u, i) : (C = c.current) == null || C.call(c, i));
+    }),
+    [t, r]
+  ), null;
+}
+function ye({ position: e = "top-left", className: t, style: n, children: r }) {
+  const { corners: l } = F("OmWidget"), a = l[e];
+  return a ? $(
+    /* @__PURE__ */ w("div", { className: t, style: { pointerEvents: "auto", ...n }, children: r }),
+    a
+  ) : null;
+}
+const se = {
+  "top-left": "translate(0, 0)",
+  "top-center": "translate(-50%, 0)",
+  "top-right": "translate(-100%, 0)",
+  "center-left": "translate(0, -50%)",
+  center: "translate(-50%, -50%)",
+  "center-right": "translate(-100%, -50%)",
+  "bottom-left": "translate(0, -100%)",
+  "bottom-center": "translate(-50%, -100%)",
+  "bottom-right": "translate(-100%, -100%)"
+};
+function he(e) {
+  const { controller: t, overlayPane: n } = F("OmOverlay"), r = d(null), l = d(void 0), [a, u] = p(null), c = d(e);
+  c.current = e, O(
+    () => t.registerOverlay((s, f) => {
+      const h = r.current;
+      if (!h) return;
+      const { anchor: I, anchorFrom: P, layer: k, visible: z = !0, anchorOffset: K } = c.current;
+      let g;
+      if (P === "selection" ? ((!k || (f == null ? void 0 : f.layerId) === k) && (l.current = (f == null ? void 0 : f.coordinate) ?? void 0, u(f)), g = l.current) : g = I, !z || !g || !s) {
+        h.style.visibility = "hidden";
+        return;
+      }
+      const [v, b, S] = s.project([g[0], g[1], 0]);
+      if (!(v >= 0 && v <= s.width && b >= 0 && b <= s.height) || S !== void 0 && S < 0) {
+        h.style.visibility = "hidden";
+        return;
+      }
+      h.style.visibility = "visible", h.style.transform = `translate(${v}px, ${b}px) ${se[K ?? "bottom-center"]}`;
+    }),
+    [t]
+  ), O(() => {
+    t.refreshOverlays();
+  });
+  const { children: i, className: y, style: x, interactive: C = !0 } = e, E = typeof i == "function" ? i(a) : i;
+  return $(
+    /* @__PURE__ */ w(
+      "div",
+      {
+        ref: r,
+        className: y,
+        style: {
+          position: "absolute",
+          top: 0,
+          left: 0,
+          visibility: "hidden",
+          // hidden until the first flush positions it — never flashes at the origin
+          willChange: "transform",
+          pointerEvents: C ? "auto" : "none",
+          ...x
+        },
+        children: E
+      }
+    ),
+    n
+  );
+}
+function me(e = []) {
+  const { controller: t } = F("useOmMap"), n = e.join(" "), r = j(() => n ? n.split(" ") : [], [n]), [l, a] = p(() => t.buildCtx());
+  return O(() => t.watch(r, a), [t, r]), l;
+}
+export {
+  de as OmLayer,
+  fe as OmMap,
+  he as OmOverlay,
+  ye as OmWidget,
+  me as useOmMap
+};