@honua/app-platform 0.0.20-alpha.0

package/web-components/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Framework-neutral Honua custom elements.
+ *
+ * Importing this module registers the shipped custom elements when a browser
+ * `customElements` registry is present. Node imports are safe; call
+ * `defineHonuaWebComponents()` explicitly when using a scoped registry.
+ *
+ * The `<honua-measure-control>` and `<honua-sketch-control>` elements need a
+ * drawing backend to be interactive. The SDK does not bundle one (no hard
+ * dependency on maplibre-gl-draw or similar); instead, supply a
+ * {@link HonuaMeasureProvider} via `measurementGeometry` and/or a
+ * {@link HonuaSketchProvider} via `sketchGeometry` to
+ * `createHonuaWebComponentController`. Without a provider both controls render
+ * disabled by design with a "configure a provider" affordance.
+ *
+ * @experimental This entrypoint is not yet covered by the SDK's semver contract
+ *   — the surface may change in any minor release prior to `1.0.0`.
+ * @module
+ */
+import "./elements.js";
+export { HonuaInMemoryWebComponentController, createHonuaWebComponentController, createHonuaWebComponentControllerFromRuntime, layersFromMapPackage, legendFromMapPackage, } from "./controller.js";
+export { HonuaActionPanelElement, HonuaBasemapControlElement, HonuaBookmarksElement, HonuaChartElement, HonuaEditorElement, HonuaFeatureTableElement, HonuaLayerListElement, HonuaLegendElement, HonuaLocateControlElement, HonuaMapElement, HonuaMapStatusElement, HonuaMeasureControlElement, HonuaPrintExportElement, HonuaSearchElement, HonuaSketchControlElement, defineHonuaWebComponents, } from "./elements.js";
+export type { HonuaActionDetail, HonuaActionPanelAction, HonuaBasemapChangeDetail, HonuaBookmark, HonuaBookmarkChangeDetail, CreateHonuaWebComponentControllerOptions, HonuaChartDatum, HonuaChartModel, HonuaComponentStatus, HonuaControllerReadyDetail, HonuaControllerStateListener, HonuaControllerSubscription, HonuaEditCapabilities, HonuaEditChangeDetail, HonuaEditRequest, HonuaEditorModel, HonuaExportDetail, HonuaFeatureRecord, HonuaFeatureStateEntry, HonuaFeatureStateTarget, HonuaFeatureTableModel, HonuaFilterChangeDetail, HonuaFilterState, HonuaFullscreenChangeDetail, HonuaLayerModel, HonuaLayerVisibilityChangeDetail, HonuaLegendItem, HonuaLocateChangeDetail, HonuaMapClickDetail, HonuaMapErrorDetail, HonuaMapHoverDetail, HonuaMapInteractionDetail, HonuaMapInteractionPoint, HonuaMapReadyDetail, HonuaMeasureChangeDetail, HonuaMeasureMode, HonuaMeasureProvider, HonuaMeasureResult, HonuaQueryFeaturesOptions, HonuaSearchDetail, HonuaSearchOptions, HonuaSearchResult, HonuaSelectionChangeDetail, HonuaSelectionState, HonuaSketchChangeDetail, HonuaSketchMode, HonuaSketchProvider, HonuaSketchResult, HonuaViewportChangeDetail, HonuaViewportState, HonuaWebComponentController, HonuaWebComponentRuntimeLike, HonuaWebComponentState, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/web-components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/web-components/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,eAAe,CAAC;AAEvB,OAAO,EACL,mCAAmC,EACnC,iCAAiC,EACjC,4CAA4C,EAC5C,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,uBAAuB,EACvB,0BAA0B,EAC1B,qBAAqB,EACrB,iBAAiB,EACjB,kBAAkB,EAClB,wBAAwB,EACxB,qBAAqB,EACrB,kBAAkB,EAClB,yBAAyB,EACzB,eAAe,EACf,qBAAqB,EACrB,0BAA0B,EAC1B,uBAAuB,EACvB,kBAAkB,EAClB,yBAAyB,EACzB,wBAAwB,GACzB,MAAM,eAAe,CAAC;AAEvB,YAAY,EACV,iBAAiB,EACjB,sBAAsB,EACtB,wBAAwB,EACxB,aAAa,EACb,yBAAyB,EACzB,wCAAwC,EACxC,eAAe,EACf,eAAe,EACf,oBAAoB,EACpB,0BAA0B,EAC1B,4BAA4B,EAC5B,2BAA2B,EAC3B,qBAAqB,EACrB,qBAAqB,EACrB,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,EACvB,gBAAgB,EAChB,2BAA2B,EAC3B,eAAe,EACf,gCAAgC,EAChC,eAAe,EACf,uBAAuB,EACvB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,yBAAyB,EACzB,wBAAwB,EACxB,mBAAmB,EACnB,wBAAwB,EACxB,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,EAClB,yBAAyB,EACzB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,0BAA0B,EAC1B,mBAAmB,EACnB,uBAAuB,EACvB,eAAe,EACf,mBAAmB,EACnB,iBAAiB,EACjB,yBAAyB,EACzB,kBAAkB,EAClB,2BAA2B,EAC3B,4BAA4B,EAC5B,sBAAsB,GACvB,MAAM,YAAY,CAAC"}

package/web-components/index.js

@@ -0,0 +1,22 @@
+/**
+ * Framework-neutral Honua custom elements.
+ *
+ * Importing this module registers the shipped custom elements when a browser
+ * `customElements` registry is present. Node imports are safe; call
+ * `defineHonuaWebComponents()` explicitly when using a scoped registry.
+ *
+ * The `<honua-measure-control>` and `<honua-sketch-control>` elements need a
+ * drawing backend to be interactive. The SDK does not bundle one (no hard
+ * dependency on maplibre-gl-draw or similar); instead, supply a
+ * {@link HonuaMeasureProvider} via `measurementGeometry` and/or a
+ * {@link HonuaSketchProvider} via `sketchGeometry` to
+ * `createHonuaWebComponentController`. Without a provider both controls render
+ * disabled by design with a "configure a provider" affordance.
+ *
+ * @experimental This entrypoint is not yet covered by the SDK's semver contract
+ *   — the surface may change in any minor release prior to `1.0.0`.
+ * @module
+ */
+import "./elements.js";
+export { HonuaInMemoryWebComponentController, createHonuaWebComponentController, createHonuaWebComponentControllerFromRuntime, layersFromMapPackage, legendFromMapPackage, } from "./controller.js";
+export { HonuaActionPanelElement, HonuaBasemapControlElement, HonuaBookmarksElement, HonuaChartElement, HonuaEditorElement, HonuaFeatureTableElement, HonuaLayerListElement, HonuaLegendElement, HonuaLocateControlElement, HonuaMapElement, HonuaMapStatusElement, HonuaMeasureControlElement, HonuaPrintExportElement, HonuaSearchElement, HonuaSketchControlElement, defineHonuaWebComponents, } from "./elements.js";

package/web-components/maplibre-renderer.d.ts

@@ -0,0 +1,22 @@
+import type { HonuaClient } from "../core/client.js";
+import type { HonuaMapClickDetail, HonuaMapErrorDetail, HonuaMapHoverDetail, HonuaMapReadyDetail, HonuaSelectionChangeDetail, HonuaViewportChangeDetail, HonuaWebComponentController, HonuaWebComponentRuntimeLike, HonuaWebComponentState } from "./types.js";
+export interface HonuaMapLibreRendererOptions<T = Record<string, unknown>> {
+    container: HTMLElement;
+    getClient(): HonuaClient | undefined;
+    getController(): HonuaWebComponentController<T> | undefined;
+    onReady(detail: HonuaMapReadyDetail<T>): void;
+    onError(detail: HonuaMapErrorDetail): void;
+    onViewport(detail: HonuaViewportChangeDetail): void;
+    onClick(detail: HonuaMapClickDetail<T>): void;
+    onHover(detail: HonuaMapHoverDetail<T>): void;
+    onSelection(detail: HonuaSelectionChangeDetail<T>): void;
+}
+export declare class HonuaMapLibreRenderer<T = Record<string, unknown>> {
+    #private;
+    constructor(options: HonuaMapLibreRendererOptions<T>);
+    get map(): unknown | undefined;
+    get runtime(): HonuaWebComponentRuntimeLike<T> | undefined;
+    applyState(state: HonuaWebComponentState<T>): Promise<void>;
+    disconnect(): void;
+}
+//# sourceMappingURL=maplibre-renderer.d.ts.map

package/web-components/maplibre-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maplibre-renderer.d.ts","sourceRoot":"","sources":["../../../src/web-components/maplibre-renderer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,KAAK,EAGV,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,EAC1B,yBAAyB,EACzB,2BAA2B,EAC3B,4BAA4B,EAC5B,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAqCpB,MAAM,WAAW,4BAA4B,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACvE,SAAS,EAAE,WAAW,CAAC;IACvB,SAAS,IAAI,WAAW,GAAG,SAAS,CAAC;IACrC,aAAa,IAAI,2BAA2B,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IAC5D,OAAO,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAC9C,OAAO,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC3C,UAAU,CAAC,MAAM,EAAE,yBAAyB,GAAG,IAAI,CAAC;IACpD,OAAO,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAC9C,OAAO,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAC9C,WAAW,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;CAC1D;AAED,qBAAa,qBAAqB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;gBAczC,OAAO,EAAE,4BAA4B,CAAC,CAAC,CAAC;IAI3D,IAAW,GAAG,IAAI,OAAO,GAAG,SAAS,CAEpC;IAED,IAAW,OAAO,IAAI,4BAA4B,CAAC,CAAC,CAAC,GAAG,SAAS,CAEhE;IAEY,UAAU,CAAC,KAAK,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBjE,UAAU,IAAI,IAAI;CAuT1B"}

package/web-components/maplibre-renderer.js

@@ -0,0 +1,474 @@
+export class HonuaMapLibreRenderer {
+    #options;
+    #interactionHandles = [];
+    #map;
+    #runtime;
+    #loadedPackageKey;
+    #loadToken = 0;
+    #lastViewportKey;
+    #syncingViewport = false;
+    #layerVisibility = new Map();
+    #selectionTarget;
+    #featureStates = new Map();
+    #state;
+    constructor(options) {
+        this.#options = options;
+    }
+    get map() {
+        return this.#map;
+    }
+    get runtime() {
+        return this.#runtime;
+    }
+    async applyState(state) {
+        this.#state = state;
+        if (!state.mapPackage)
+            return;
+        const packageKey = mapPackageKey(state.mapPackage);
+        if (!this.#runtime || this.#loadedPackageKey !== packageKey) {
+            await this.#load(state.mapPackage);
+            if (!this.#runtime)
+                return;
+        }
+        this.#applyLayerVisibility(state);
+        this.#applyViewport(state);
+        this.#applyFeatureStates(state.featureStates);
+        this.#applySelection(state);
+    }
+    disconnect() {
+        this.#loadToken += 1;
+        this.#removeInteractions();
+        this.#runtime?.dispose();
+        this.#runtime = undefined;
+        this.#map?.remove?.();
+        this.#map = undefined;
+        this.#loadedPackageKey = undefined;
+        this.#layerVisibility.clear();
+        this.#featureStates.clear();
+        this.#selectionTarget = undefined;
+        this.#options.container.replaceChildren();
+    }
+    async #load(mapPackage) {
+        const token = ++this.#loadToken;
+        this.#removeOwnedMap();
+        try {
+            const [{ loadMapPackage }, maplibregl] = await Promise.all([
+                import("../runtime/index.js"),
+                import("maplibre-gl"),
+            ]);
+            if (token !== this.#loadToken)
+                return;
+            const MapCtor = maplibregl.default?.Map ?? maplibregl.Map;
+            if (!MapCtor)
+                throw new Error("maplibre-gl did not export Map.");
+            const map = new MapCtor({
+                container: this.#options.container,
+                style: emptyStyle(),
+                center: mapPackage.initialView?.center ?? [0, 0],
+                zoom: mapPackage.initialView?.zoom ?? 0,
+                bearing: mapPackage.initialView?.bearing ?? 0,
+                pitch: mapPackage.initialView?.pitch ?? 0,
+                attributionControl: false,
+                preserveDrawingBuffer: true,
+            });
+            this.#map = map;
+            const runtime = await loadMapPackage(mapPackage, map, {
+                client: this.#options.getClient() ?? (await createDefaultClient()),
+                skipCompatibilityCheck: true,
+                onEvent: (event) => {
+                    if (event.type === "source-error") {
+                        this.#emitError(event.error, event.sourceId);
+                    }
+                },
+            });
+            if (token !== this.#loadToken) {
+                runtime.dispose();
+                map.remove?.();
+                return;
+            }
+            this.#runtime = runtime;
+            this.#loadedPackageKey = mapPackageKey(mapPackage);
+            this.#bindViewport(map);
+            this.#bindLayerInteractions(runtime);
+            map.resize?.();
+            await waitForMapReady(map);
+            if (token !== this.#loadToken)
+                return;
+            this.#options.onReady({
+                map,
+                runtime: runtime,
+                controller: this.#options.getController(),
+                mapPackage,
+            });
+        }
+        catch (error) {
+            if (token !== this.#loadToken)
+                return;
+            this.#emitError(error);
+            this.#removeOwnedMap();
+        }
+    }
+    #removeOwnedMap() {
+        this.#removeInteractions();
+        this.#runtime?.dispose();
+        this.#runtime = undefined;
+        this.#map?.remove?.();
+        this.#map = undefined;
+        this.#layerVisibility.clear();
+        this.#featureStates.clear();
+        this.#selectionTarget = undefined;
+        this.#options.container.replaceChildren();
+    }
+    #bindViewport(map) {
+        const emit = () => {
+            const detail = viewportFromMap(map);
+            if (!detail)
+                return;
+            this.#lastViewportKey = viewportKey(detail);
+            this.#syncingViewport = true;
+            try {
+                this.#options.getController()?.setViewport(detail);
+            }
+            finally {
+                this.#syncingViewport = false;
+            }
+            this.#options.onViewport(detail);
+        };
+        map.on("moveend", emit);
+        this.#interactionHandles.push({ remove: () => map.off("moveend", emit) });
+    }
+    #bindLayerInteractions(runtime) {
+        for (const layer of runtime.composedStyle.layers) {
+            if (!layer.source)
+                continue;
+            this.#bindHover(runtime, layer);
+            this.#bindClick(runtime, layer);
+        }
+    }
+    #bindHover(runtime, layer) {
+        try {
+            this.#interactionHandles.push(runtime.bindHover(layer.id));
+        }
+        catch (error) {
+            this.#emitError(error);
+            return;
+        }
+        const sourceId = layer.source;
+        if (!sourceId)
+            return;
+        const sourceLayer = layer["source-layer"];
+        const onMove = (event) => {
+            const mapFeature = firstEventFeature(event);
+            const featureId = featureIdFromMapFeature(mapFeature);
+            const feature = featureId !== undefined
+                ? (this.#findFeature(sourceId, featureId) ?? featureRecordFromMapFeature(sourceId, featureId, mapFeature))
+                : undefined;
+            this.#options.onHover({
+                hovering: featureId !== undefined,
+                layerId: layer.id,
+                sourceId,
+                ...(sourceLayer !== undefined ? { sourceLayer } : {}),
+                ...(featureId !== undefined ? { featureId } : {}),
+                ...(feature !== undefined ? { feature } : {}),
+                ...(mapFeature !== undefined ? { mapFeature } : {}),
+                ...eventPosition(event),
+                originalEvent: event,
+            });
+        };
+        const onLeave = (event) => {
+            this.#options.onHover({
+                hovering: false,
+                layerId: layer.id,
+                sourceId,
+                ...(sourceLayer !== undefined ? { sourceLayer } : {}),
+                ...eventPosition(event),
+                originalEvent: event,
+            });
+        };
+        runtime.map.on("mousemove", layer.id, onMove);
+        runtime.map.on("mouseleave", layer.id, onLeave);
+        this.#interactionHandles.push({
+            remove: () => {
+                runtime.map.off("mousemove", layer.id, onMove);
+                runtime.map.off("mouseleave", layer.id, onLeave);
+            },
+        });
+    }
+    #bindClick(runtime, layer) {
+        try {
+            this.#interactionHandles.push(runtime.bindClick(layer.id, (event) => {
+                const sourceId = event.selectionTarget?.sourceId ?? event.sourceId;
+                const sourceLayer = event.selectionTarget?.sourceLayer ?? event.sourceLayer;
+                const featureId = event.selectionTarget?.id ?? event.featureId;
+                const feature = featureId !== undefined
+                    ? (this.#findFeature(sourceId, featureId) ??
+                        featureRecordFromMapFeature(sourceId, featureId, event.feature))
+                    : undefined;
+                const detail = {
+                    layerId: event.layerId,
+                    sourceId,
+                    ...(sourceLayer !== undefined ? { sourceLayer } : {}),
+                    ...(featureId !== undefined ? { featureId } : {}),
+                    ...(feature ? { feature } : {}),
+                    ...(event.feature !== undefined ? { mapFeature: event.feature } : {}),
+                    ...eventPosition(event.originalEvent),
+                    originalEvent: event.originalEvent,
+                };
+                this.#options.onClick(detail);
+                if (featureId === undefined)
+                    return;
+                const selection = {
+                    sourceId,
+                    ...(sourceLayer !== undefined ? { sourceLayer } : {}),
+                    featureId,
+                    ...(feature ? { feature } : {}),
+                };
+                this.#options.getController()?.selectFeature(selection);
+                this.#options.onSelection(selection);
+            }));
+        }
+        catch (error) {
+            this.#emitError(error);
+        }
+    }
+    #applyLayerVisibility(state) {
+        const runtime = this.#runtime;
+        if (!runtime)
+            return;
+        for (const layer of state.layers) {
+            const previous = this.#layerVisibility.get(layer.id);
+            if (previous === layer.visible)
+                continue;
+            this.#layerVisibility.set(layer.id, layer.visible);
+            try {
+                runtime.setLayerVisibility(layer.id, layer.visible);
+            }
+            catch (error) {
+                this.#emitError(error);
+            }
+        }
+    }
+    #applyViewport(state) {
+        if (this.#syncingViewport || !this.#runtime)
+            return;
+        const key = viewportKey(state.viewport);
+        if (key === this.#lastViewportKey)
+            return;
+        this.#lastViewportKey = key;
+        try {
+            this.#runtime.setViewState(state.viewport);
+        }
+        catch (error) {
+            this.#emitError(error);
+        }
+    }
+    #applySelection(state) {
+        const runtime = this.#runtime;
+        if (!runtime)
+            return;
+        const next = selectionFeatureState(state);
+        const previous = this.#selectionTarget;
+        if (previous && (!next || featureStateKey(previous) !== featureStateKey(next))) {
+            this.#removeFeatureState(previous, "selected");
+        }
+        if (next)
+            this.#setFeatureState(next, { selected: true });
+        this.#selectionTarget = next;
+    }
+    #applyFeatureStates(entries) {
+        for (const [key, previous] of this.#featureStates) {
+            const next = entries.find((entry) => featureStateKey(entry) === key);
+            if (!next) {
+                this.#removeFeatureState(previous);
+                this.#featureStates.delete(key);
+                continue;
+            }
+            for (const previousKey of Object.keys(previous.state)) {
+                if (!Object.hasOwn(next.state, previousKey))
+                    this.#removeFeatureState(previous, previousKey);
+            }
+        }
+        for (const entry of entries) {
+            const key = featureStateKey(entry);
+            const previous = this.#featureStates.get(key);
+            if (!previous || stableKey(previous.state) !== stableKey(entry.state)) {
+                this.#setFeatureState(entry, entry.state);
+            }
+            this.#featureStates.set(key, copyFeatureStateEntry(entry));
+        }
+    }
+    #setFeatureState(target, state) {
+        try {
+            this.#runtime?.setFeatureStateForTarget({
+                sourceId: target.sourceId,
+                id: target.featureId,
+                ...(target.sourceLayer !== undefined ? { sourceLayer: target.sourceLayer } : {}),
+            }, state);
+        }
+        catch (error) {
+            this.#emitError(error);
+        }
+    }
+    #removeFeatureState(target, key) {
+        try {
+            this.#runtime?.removeFeatureStateForTarget({
+                sourceId: target.sourceId,
+                id: target.featureId,
+                ...(target.sourceLayer !== undefined ? { sourceLayer: target.sourceLayer } : {}),
+            }, key);
+        }
+        catch (error) {
+            this.#emitError(error);
+        }
+    }
+    #findFeature(sourceId, featureId) {
+        return this.#state?.featuresBySource[sourceId]?.find((feature) => String(feature.id) === String(featureId));
+    }
+    #removeInteractions() {
+        for (const handle of this.#interactionHandles.splice(0)) {
+            handle.remove();
+        }
+    }
+    #emitError(error, sourceId) {
+        this.#options.onError({
+            error,
+            message: error instanceof Error ? error.message : String(error),
+            ...(sourceId ? { sourceId } : {}),
+        });
+    }
+}
+async function createDefaultClient() {
+    const { HonuaClient } = await import("../core/client.js");
+    const origin = typeof window !== "undefined" && window.location?.origin ? window.location.origin : "http://localhost";
+    return new HonuaClient({ baseUrl: origin });
+}
+function emptyStyle() {
+    return {
+        version: 8,
+        sources: {},
+        layers: [
+            {
+                id: "honua-empty-background",
+                type: "background",
+                paint: { "background-color": "#e8eef7" },
+            },
+        ],
+    };
+}
+function mapPackageKey(mapPackage) {
+    return `${mapPackage.mapPackageId}:${stableKey({
+        sources: Object.keys(mapPackage.mapSpec.sources).sort(),
+        layers: mapPackage.mapSpec.layers.map((layer) => [layer.id, layer.type, layer.source]),
+        initialView: mapPackage.initialView,
+    })}`;
+}
+function selectionFeatureState(state) {
+    const sourceId = state.selection?.sourceId;
+    const sourceLayer = state.selection?.sourceLayer;
+    const featureId = state.selection?.featureId;
+    if (sourceId === undefined || featureId === undefined)
+        return undefined;
+    return { sourceId, ...(sourceLayer !== undefined ? { sourceLayer } : {}), featureId, state: { selected: true } };
+}
+function copyFeatureStateEntry(entry) {
+    return {
+        sourceId: entry.sourceId,
+        featureId: entry.featureId,
+        ...(entry.sourceLayer !== undefined ? { sourceLayer: entry.sourceLayer } : {}),
+        state: { ...entry.state },
+    };
+}
+function featureStateKey(target) {
+    return `${target.sourceId}\u0000${target.sourceLayer ?? ""}\u0000${typeof target.featureId}:${String(target.featureId)}`;
+}
+function stableKey(value) {
+    return JSON.stringify(value);
+}
+function viewportKey(viewport) {
+    return JSON.stringify({
+        bbox: viewport.bbox,
+        center: viewport.center,
+        zoom: viewport.zoom,
+        pitch: viewport.pitch,
+        bearing: viewport.bearing,
+    });
+}
+function firstEventFeature(event) {
+    if (typeof event !== "object" || event === null || !("features" in event))
+        return undefined;
+    const features = event.features;
+    return Array.isArray(features) ? features[0] : undefined;
+}
+function featureIdFromMapFeature(feature) {
+    if (typeof feature !== "object" || feature === null || !("id" in feature))
+        return undefined;
+    const id = feature.id;
+    return typeof id === "string" || typeof id === "number" ? id : undefined;
+}
+function featureRecordFromMapFeature(sourceId, featureId, feature) {
+    if (typeof feature !== "object" || feature === null)
+        return undefined;
+    const candidate = feature;
+    const attributes = candidate.properties && typeof candidate.properties === "object"
+        ? { ...candidate.properties }
+        : {};
+    return {
+        id: featureId,
+        sourceId,
+        attributes,
+        ...(candidate.geometry !== undefined ? { geometry: candidate.geometry } : {}),
+        title: featureTitle(attributes, featureId),
+    };
+}
+function featureTitle(attributes, id) {
+    const values = attributes && typeof attributes === "object" ? attributes : {};
+    for (const key of ["name", "Name", "NAME", "title", "Title", "TITLE", "label", "Label", "LABEL"]) {
+        const value = values[key];
+        if (typeof value === "string" && value.trim())
+            return value;
+    }
+    const firstString = Object.values(values).find((value) => typeof value === "string" && value.trim());
+    return typeof firstString === "string" ? firstString : String(id);
+}
+function eventPosition(event) {
+    if (typeof event !== "object" || event === null)
+        return {};
+    const values = event;
+    return {
+        ...(typeof values.point?.x === "number" && typeof values.point.y === "number"
+            ? { point: { x: values.point.x, y: values.point.y } }
+            : {}),
+        ...(typeof values.lngLat?.lng === "number" && typeof values.lngLat.lat === "number"
+            ? { lngLat: [values.lngLat.lng, values.lngLat.lat] }
+            : {}),
+    };
+}
+function viewportFromMap(map) {
+    const center = map.getCenter?.();
+    const bounds = map.getBounds?.();
+    return {
+        ...(bounds ? { bbox: [bounds.getWest(), bounds.getSouth(), bounds.getEast(), bounds.getNorth()] } : {}),
+        ...(center ? { center: [center.lng, center.lat] } : {}),
+        ...(map.getZoom ? { zoom: map.getZoom() } : {}),
+        ...(map.getPitch ? { pitch: map.getPitch() } : {}),
+        ...(map.getBearing ? { bearing: map.getBearing() } : {}),
+    };
+}
+async function waitForMapReady(map) {
+    if (map.loaded?.() || map.isStyleLoaded?.())
+        return;
+    await new Promise((resolve) => {
+        const done = () => {
+            clearTimeout(timeout);
+            resolve();
+        };
+        const timeout = setTimeout(done, 2500);
+        if (map.once) {
+            map.once("idle", done);
+            map.once("load", done);
+        }
+        else {
+            done();
+        }
+    });
+}