aur-openlayers 0.0.1

package/fesm2022/aur-openlayers.mjs

@@ -0,0 +1,2118 @@
+import * as i0 from '@angular/core';
+import { Injectable, Component } from '@angular/core';
+import VectorLayer from 'ol/layer/Vector';
+import ClusterSource from 'ol/source/Cluster';
+import VectorSource from 'ol/source/Vector';
+import Feature from 'ol/Feature';
+import Collection from 'ol/Collection';
+import DragPan from 'ol/interaction/DragPan';
+import Modify from 'ol/interaction/Modify';
+import * as Observable from 'ol/Observable';
+import { createEmpty, extend, isEmpty } from 'ol/extent';
+
+class LibService {
+    constructor() { }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: LibService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: LibService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: LibService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+class LibComponent {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: LibComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.18", type: LibComponent, isStandalone: true, selector: "lib-lib", ngImport: i0, template: `
+    <p>
+      lib works!
+    </p>
+  `, isInline: true, styles: [""] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: LibComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-lib', imports: [], template: `
+    <p>
+      lib works!
+    </p>
+  ` }]
+        }] });
+
+class FlushScheduler {
+    defaultPolicy;
+    queue = new Map();
+    pendingPolicy = null;
+    scheduledToken = 0;
+    rafId = null;
+    batchDepth = 0;
+    policyStack = [];
+    constructor(defaultPolicy = 'microtask') {
+        this.defaultPolicy = defaultPolicy;
+    }
+    batch(fn, options) {
+        if (options?.policy) {
+            this.policyStack.push(options.policy);
+        }
+        this.batchDepth += 1;
+        try {
+            fn();
+        }
+        finally {
+            this.batchDepth = Math.max(0, this.batchDepth - 1);
+            if (options?.policy) {
+                this.policyStack.pop();
+            }
+            if (this.batchDepth === 0 && (this.pendingPolicy !== null || this.queue.size > 0)) {
+                const policy = this.pendingPolicy ?? this.currentPolicy();
+                this.pendingPolicy = policy;
+                this.scheduleFlush(policy);
+            }
+        }
+    }
+    schedule(key, task, policy) {
+        this.queue.set(key, task);
+        this.requestFlush(policy);
+    }
+    requestFlush(policy) {
+        const desired = policy ?? this.currentPolicy();
+        if (this.batchDepth > 0) {
+            this.pendingPolicy = this.combinePolicies(this.pendingPolicy, desired);
+            return;
+        }
+        if (this.pendingPolicy) {
+            if (this.shouldUpgradePolicy(this.pendingPolicy, desired)) {
+                this.pendingPolicy = desired;
+                this.scheduleFlush(desired);
+            }
+            return;
+        }
+        this.pendingPolicy = desired;
+        this.scheduleFlush(desired);
+    }
+    scheduleFlush(policy) {
+        const token = ++this.scheduledToken;
+        if (policy === 'raf') {
+            if (this.rafId !== null) {
+                cancelAnimationFrame(this.rafId);
+            }
+            this.rafId = requestAnimationFrame(() => this.flush('raf', token));
+            return;
+        }
+        queueMicrotask(() => this.flush('microtask', token));
+    }
+    flush(policy, token) {
+        if (token !== this.scheduledToken || this.pendingPolicy !== policy) {
+            return;
+        }
+        this.pendingPolicy = null;
+        if (policy === 'raf') {
+            this.rafId = null;
+        }
+        const tasks = Array.from(this.queue.values());
+        this.queue.clear();
+        tasks.forEach((task) => task());
+    }
+    currentPolicy() {
+        if (this.policyStack.length > 0) {
+            return this.policyStack[this.policyStack.length - 1];
+        }
+        return this.defaultPolicy;
+    }
+    combinePolicies(current, next) {
+        if (!current) {
+            return next;
+        }
+        return current === 'raf' || next === 'raf' ? 'raf' : 'microtask';
+    }
+    shouldUpgradePolicy(current, next) {
+        return current === 'microtask' && next === 'raf';
+    }
+}
+
+const createMapContext = (map, layers, popupHost, scheduler = new FlushScheduler()) => {
+    return {
+        map,
+        layers,
+        popupHost,
+        batch: (fn, options) => scheduler.batch(fn, options),
+    };
+};
+
+const CLUSTER_FEATURES_KEY = 'features';
+const getClusterFeatures = (feature) => {
+    const features = feature.get(CLUSTER_FEATURES_KEY);
+    if (!Array.isArray(features)) {
+        return null;
+    }
+    const items = features.filter((item) => {
+        if (!item || typeof item !== 'object') {
+            return false;
+        }
+        const candidate = item;
+        return typeof candidate.get === 'function' && typeof candidate.getGeometry === 'function';
+    });
+    if (items.length === 0) {
+        return null;
+    }
+    return items;
+};
+
+/**
+ * Default padding for View#fit in pixels.
+ * Order: [top, right, bottom, left]
+ */
+const DEFAULT_OL_PADDING = [64, 64, 64, 64];
+const DEFAULT_FIT_DURATION = 500;
+function toOlPadding(p, fallback = DEFAULT_OL_PADDING) {
+    if (!p) {
+        return fallback;
+    }
+    if ('all' in p) {
+        const a = p.all;
+        return [a, a, a, a];
+    }
+    if ('vertical' in p && 'horizontal' in p) {
+        return [p.vertical, p.horizontal, p.vertical, p.horizontal];
+    }
+    return [p.top, p.right, p.bottom, p.left];
+}
+function toOlFitOptions(opts) {
+    const padding = toOlPadding(opts?.padding) ?? DEFAULT_OL_PADDING;
+    const duration = opts?.duration ?? DEFAULT_FIT_DURATION;
+    // OL View#fit options are a plain object; keep it minimal & typed-friendly
+    const fitOpts = { padding, duration };
+    if (opts?.maxZoom != null) {
+        fitOpts.maxZoom = opts.maxZoom;
+    }
+    return fitOpts;
+}
+
+const STATES_KEY = '__mff_states__';
+const getFeatureStates = (feature) => {
+    const states = feature.get(STATES_KEY);
+    if (Array.isArray(states)) {
+        return states;
+    }
+    if (typeof states === 'string') {
+        return [states];
+    }
+    return [];
+};
+const setFeatureStates = (feature, states) => {
+    feature.set(STATES_KEY, states);
+};
+const clearFeatureStates = (feature) => {
+    feature.set(STATES_KEY, []);
+};
+
+class InteractionManager {
+    ctx;
+    map;
+    schema;
+    layers;
+    apis;
+    hitTest;
+    hoverItems = new Map();
+    selectedItems = new Map();
+    activeTranslates = new Map();
+    activeModifies = new Map();
+    nativeModifies = new Map();
+    popupStack;
+    listenerKeys = new Map();
+    enabledState = new Map();
+    dragPanLocks = 0;
+    dragPanStates;
+    currentCursor;
+    constructor(options) {
+        this.ctx = options.ctx;
+        this.map = options.map;
+        this.schema = options.schema;
+        this.layers = options.layers;
+        this.apis = options.apis;
+        this.hitTest = options.hitTest ?? this.createDefaultHitTest();
+        this.popupStack = this.schema.options?.popupHost?.stack ?? 'stop';
+        this.refreshEnabled();
+    }
+    refreshEnabled() {
+        const popupEnabled = this.isEnabled(this.schema.options?.popupHost?.enabled);
+        if (!popupEnabled) {
+            this.ctx.popupHost?.clear();
+        }
+        const nextState = new Map();
+        this.schema.layers.forEach((descriptor) => {
+            const interactions = descriptor.feature.interactions;
+            nextState.set(descriptor.id, {
+                click: !!interactions?.click && this.isEnabled(interactions.click.enabled),
+                doubleClick: !!interactions?.doubleClick && this.isEnabled(interactions.doubleClick.enabled),
+                hover: !!interactions?.hover && this.isEnabled(interactions.hover.enabled),
+                select: !!interactions?.select && this.isEnabled(interactions.select.enabled),
+                translate: !!interactions?.translate && this.isEnabled(interactions.translate.enabled),
+                modify: !!interactions?.modify && this.isEnabled(interactions.modify.enabled),
+            });
+        });
+        this.syncNativeModify(nextState);
+        this.applyDisabledCleanup(nextState);
+        this.enabledState.clear();
+        nextState.forEach((value, key) => this.enabledState.set(key, value));
+        this.syncListeners(popupEnabled);
+    }
+    handlePointerDown(event) {
+        if (!this.isListening('pointerdown')) {
+            return;
+        }
+        const layers = this.getOrderedLayers();
+        for (const entry of layers) {
+            const interactions = entry.descriptor.feature.interactions;
+            const translate = interactions?.translate;
+            if (translate && this.isEnabled(translate.enabled)) {
+                const { items: candidates } = this.hitTest({
+                    layerId: entry.descriptor.id,
+                    layer: entry.layer,
+                    api: entry.api,
+                    descriptor: entry.descriptor,
+                    event,
+                    hitTolerance: this.getHitTolerance(translate.hitTolerance),
+                });
+                if (candidates.length > 0) {
+                    const translateEvent = this.createTranslateEvent(event, event.coordinate, 'translatestart', candidates);
+                    let target;
+                    if (translate.pickTarget) {
+                        target = translate.pickTarget({ candidates, ctx: this.ctx, event: translateEvent });
+                    }
+                    else {
+                        target = candidates[0];
+                    }
+                    if (target) {
+                        const targetKey = entry.descriptor.feature.id(target.model);
+                        const resolved = this.resolveTarget(entry, targetKey);
+                        if (resolved) {
+                            const active = {
+                                targetKey,
+                                startCoordinate: event.coordinate,
+                                lastCoordinate: event.coordinate,
+                                lastItem: resolved,
+                                moveThrottleMs: translate.moveThrottleMs ?? 0,
+                                translate,
+                            };
+                            this.activeTranslates.set(entry.descriptor.id, active);
+                            this.lockDragPan();
+                            if (translate.state) {
+                                this.applyState([resolved], translate.state, true);
+                            }
+                            const handled = translate.onStart
+                                ? this.isHandled(translate.onStart({ item: resolved, ctx: this.ctx, event: translateEvent }))
+                                : false;
+                            active.lastHandled = handled;
+                            if (handled && this.shouldStopPropagation(translate)) {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            if (this.activeTranslates.has(entry.descriptor.id)) {
+                continue;
+            }
+        }
+        this.updateCursor(event);
+    }
+    handlePointerDrag(event) {
+        if (!this.isListening('pointerdrag')) {
+            return;
+        }
+        if (this.activeTranslates.size === 0 && this.activeModifies.size === 0) {
+            return;
+        }
+        for (const entry of this.getOrderedLayers()) {
+            const active = this.activeTranslates.get(entry.descriptor.id);
+            if (!active) {
+                const activeModify = this.activeModifies.get(entry.descriptor.id);
+                if (!activeModify) {
+                    continue;
+                }
+                const modify = activeModify.modify;
+                const execute = () => this.applyModifyChange(entry, activeModify, event);
+                if (activeModify.moveThrottleMs > 0) {
+                    if (!activeModify.throttleTimer) {
+                        execute();
+                        activeModify.throttleTimer = setTimeout(() => {
+                            activeModify.throttleTimer = undefined;
+                            if (activeModify.pendingEvent) {
+                                const pending = activeModify.pendingEvent;
+                                activeModify.pendingEvent = undefined;
+                                this.applyModifyChange(entry, activeModify, pending);
+                            }
+                        }, activeModify.moveThrottleMs);
+                    }
+                    else {
+                        activeModify.pendingEvent = event;
+                    }
+                }
+                else {
+                    execute();
+                }
+                if (activeModify.lastHandled && this.shouldStopPropagation(modify)) {
+                    break;
+                }
+                continue;
+            }
+            const translate = active.translate;
+            const execute = () => this.applyTranslateMove(entry, active, event);
+            if (active.moveThrottleMs > 0) {
+                if (!active.throttleTimer) {
+                    execute();
+                    active.throttleTimer = setTimeout(() => {
+                        active.throttleTimer = undefined;
+                        if (active.pendingEvent) {
+                            const pending = active.pendingEvent;
+                            active.pendingEvent = undefined;
+                            this.applyTranslateMove(entry, active, pending);
+                        }
+                    }, active.moveThrottleMs);
+                }
+                else {
+                    active.pendingEvent = event;
+                }
+            }
+            else {
+                execute();
+            }
+            if (active.lastHandled && this.shouldStopPropagation(translate)) {
+                break;
+            }
+        }
+        this.updateCursor(event);
+    }
+    handlePointerUp(event) {
+        if (!this.isListening('pointerup')) {
+            return;
+        }
+        if (this.activeTranslates.size === 0 && this.activeModifies.size === 0) {
+            return;
+        }
+        for (const entry of this.getOrderedLayers()) {
+            const active = this.activeTranslates.get(entry.descriptor.id);
+            if (active) {
+                const translate = active.translate;
+                if (active.throttleTimer) {
+                    clearTimeout(active.throttleTimer);
+                    active.throttleTimer = undefined;
+                }
+                if (active.pendingEvent) {
+                    const pending = active.pendingEvent;
+                    active.pendingEvent = undefined;
+                    this.applyTranslateMove(entry, active, pending);
+                }
+                const resolved = this.resolveTarget(entry, active.targetKey);
+                if (resolved && translate.onEnd) {
+                    const translateEvent = this.createTranslateEvent(event, active.startCoordinate, 'translateend', [resolved]);
+                    active.lastHandled = this.isHandled(translate.onEnd({ item: resolved, ctx: this.ctx, event: translateEvent }));
+                }
+                else {
+                    active.lastHandled = false;
+                }
+                this.finishTranslate(entry, active, resolved);
+                if (active.lastHandled && this.shouldStopPropagation(translate)) {
+                    break;
+                }
+                continue;
+            }
+            const activeModify = this.activeModifies.get(entry.descriptor.id);
+            if (!activeModify) {
+                continue;
+            }
+            const modify = activeModify.modify;
+            if (activeModify.throttleTimer) {
+                clearTimeout(activeModify.throttleTimer);
+                activeModify.throttleTimer = undefined;
+            }
+            if (activeModify.pendingEvent) {
+                const pending = activeModify.pendingEvent;
+                activeModify.pendingEvent = undefined;
+                this.applyModifyChange(entry, activeModify, pending);
+            }
+            const resolved = this.resolveTarget(entry, activeModify.targetKey);
+            if (resolved && modify.onEnd) {
+                const modifyEvent = this.createModifyEvent(event, 'modifyend', [resolved]);
+                activeModify.lastHandled = this.isHandled(modify.onEnd({ item: resolved, ctx: this.ctx, event: modifyEvent }));
+            }
+            else {
+                activeModify.lastHandled = false;
+            }
+            this.finishModify(entry, activeModify, resolved);
+            if (activeModify.lastHandled && this.shouldStopPropagation(modify)) {
+                break;
+            }
+        }
+        this.updateCursor(event);
+    }
+    handlePointerMove(event) {
+        if (!this.isListening('pointermove')) {
+            return;
+        }
+        const popupHost = this.ctx.popupHost;
+        const popupEnabled = this.isEnabled(this.schema.options?.popupHost?.enabled);
+        const autoMode = popupEnabled ? this.schema.options?.popupHost?.autoMode ?? 'off' : 'off';
+        const autoHover = autoMode === 'hover';
+        const popupItems = [];
+        let popupStopped = false;
+        const layers = this.getOrderedLayers();
+        for (const entry of layers) {
+            const hover = entry.descriptor.feature.interactions?.hover;
+            const hoverEnabled = !!hover && this.isEnabled(hover.enabled);
+            if (!hoverEnabled && !autoHover) {
+                continue;
+            }
+            const hitResult = this.hitTest({
+                layerId: entry.descriptor.id,
+                layer: entry.layer,
+                api: entry.api,
+                descriptor: entry.descriptor,
+                event,
+                hitTolerance: this.getHitTolerance(hoverEnabled ? hover.hitTolerance : undefined),
+            });
+            if (hoverEnabled) {
+                const handled = this.processHover(entry, hover, hitResult.items, event);
+                if (handled && this.shouldStopPropagation(hover)) {
+                    break;
+                }
+            }
+            if (autoHover && popupHost && !popupStopped) {
+                const collected = this.collectPopupItems(entry, hitResult, event);
+                if (collected.length > 0) {
+                    popupItems.push(...collected);
+                    if (this.popupStack === 'stop') {
+                        popupStopped = true;
+                    }
+                }
+            }
+        }
+        if (autoHover && popupHost) {
+            popupHost.set(popupItems);
+        }
+        this.updateCursor(event);
+    }
+    handleSingleClick(event) {
+        if (!this.isListening('singleclick')) {
+            return;
+        }
+        const popupHost = this.ctx.popupHost;
+        const popupEnabled = this.isEnabled(this.schema.options?.popupHost?.enabled);
+        const autoMode = popupEnabled ? this.schema.options?.popupHost?.autoMode ?? 'off' : 'off';
+        const autoClick = autoMode === 'click';
+        const popupItems = [];
+        let popupStopped = false;
+        const layers = this.getOrderedLayers();
+        for (const entry of layers) {
+            const select = entry.descriptor.feature.interactions?.select;
+            const click = entry.descriptor.feature.interactions?.click;
+            const selectEnabled = select && this.isEnabled(select.enabled);
+            const clickEnabled = click && this.isEnabled(click.enabled);
+            const clusteringEnabled = !!entry.descriptor.clustering && !!entry.api.isClusteringEnabled?.();
+            if (!selectEnabled && !clickEnabled && !clusteringEnabled && !autoClick) {
+                continue;
+            }
+            const tolerances = [
+                selectEnabled ? select?.hitTolerance : undefined,
+                clickEnabled ? click?.hitTolerance : undefined,
+            ].filter((value) => value !== undefined);
+            const hitTolerance = tolerances.length > 0 ? Math.max(...tolerances) : this.getHitTolerance(undefined);
+            const hitResult = this.hitTest({
+                layerId: entry.descriptor.id,
+                layer: entry.layer,
+                api: entry.api,
+                descriptor: entry.descriptor,
+                event,
+                hitTolerance,
+            });
+            if (clusteringEnabled && hitResult.cluster) {
+                if (autoClick && popupHost && !popupStopped) {
+                    const collected = this.collectPopupItems(entry, hitResult, event);
+                    if (collected.length > 0) {
+                        popupItems.push(...collected);
+                        if (this.popupStack === 'stop') {
+                            popupStopped = true;
+                        }
+                    }
+                }
+                const handled = this.handleClusterClick(entry, hitResult.cluster, event, !autoClick);
+                if (handled) {
+                    if (this.shouldStopClusterPropagation()) {
+                        break;
+                    }
+                    continue;
+                }
+            }
+            if (selectEnabled || clickEnabled) {
+                const selectItems = selectEnabled ? hitResult.items : [];
+                const clickItems = clickEnabled ? hitResult.items : [];
+                const selectHandled = selectEnabled
+                    ? this.processSelect(entry, select, selectItems, event)
+                    : false;
+                const selectStops = selectHandled && this.shouldStopPropagation(select);
+                const allowClick = !selectHandled || (selectEnabled && this.shouldContinuePropagation(select));
+                if (clickEnabled && allowClick) {
+                    const clickHandled = this.processClick(entry, click, clickItems, event);
+                    if (clickHandled && this.shouldStopPropagation(click)) {
+                        break;
+                    }
+                }
+                if (selectStops) {
+                    break;
+                }
+            }
+            if (autoClick && popupHost && !popupStopped && !(clusteringEnabled && hitResult.cluster)) {
+                const collected = this.collectPopupItems(entry, hitResult, event);
+                if (collected.length > 0) {
+                    popupItems.push(...collected);
+                    if (this.popupStack === 'stop') {
+                        popupStopped = true;
+                    }
+                }
+            }
+        }
+        if (autoClick && popupHost) {
+            popupHost.set(popupItems);
+        }
+    }
+    handleDoubleClick(event) {
+        if (!this.isListening('dblclick')) {
+            return;
+        }
+        const layers = this.getOrderedLayers();
+        for (const entry of layers) {
+            const doubleClick = entry.descriptor.feature.interactions?.doubleClick;
+            if (!doubleClick || !this.isEnabled(doubleClick.enabled)) {
+                continue;
+            }
+            const hitResult = this.hitTest({
+                layerId: entry.descriptor.id,
+                layer: entry.layer,
+                api: entry.api,
+                descriptor: entry.descriptor,
+                event,
+                hitTolerance: this.getHitTolerance(doubleClick.hitTolerance),
+            });
+            if (entry.descriptor.clustering && entry.api.isClusteringEnabled?.() && hitResult.cluster) {
+                continue;
+            }
+            const { items } = hitResult;
+            const handled = this.processDoubleClick(entry, doubleClick, items, event);
+            if (handled && this.shouldStopPropagation(doubleClick)) {
+                break;
+            }
+        }
+    }
+    runInteractionMutation(fn) {
+        const policy = this.schema.options?.scheduler?.interactionPolicy;
+        if (policy) {
+            this.ctx.batch(fn, { policy });
+            return;
+        }
+        fn();
+    }
+    syncListeners(popupEnabled) {
+        const autoMode = popupEnabled ? this.schema.options?.popupHost?.autoMode ?? 'off' : 'off';
+        const needsHover = autoMode === 'hover';
+        const needsClick = autoMode === 'click';
+        let needsPointerMove = needsHover;
+        let needsSingleClick = needsClick;
+        let needsDoubleClick = false;
+        let needsPointerDown = false;
+        let needsPointerDrag = false;
+        let needsPointerUp = false;
+        this.schema.layers.forEach((descriptor) => {
+            const state = this.enabledState.get(descriptor.id);
+            if (state?.hover) {
+                needsPointerMove = true;
+            }
+            if (state?.click || state?.select) {
+                needsSingleClick = true;
+            }
+            if (state?.doubleClick) {
+                needsDoubleClick = true;
+            }
+            if (state?.translate || state?.modify) {
+                needsPointerDown = true;
+                needsPointerDrag = true;
+                needsPointerUp = true;
+            }
+            const interactions = descriptor.feature.interactions;
+            if (interactions && this.hasCursorInteraction(interactions)) {
+                needsPointerMove = true;
+            }
+            if (descriptor.clustering &&
+                (descriptor.clustering.expandOnClick || descriptor.clustering.popup)) {
+                needsSingleClick = true;
+            }
+        });
+        this.toggleListener('pointermove', needsPointerMove, (event) => this.handlePointerMove(event));
+        this.toggleListener('singleclick', needsSingleClick, (event) => this.handleSingleClick(event));
+        this.toggleListener('dblclick', needsDoubleClick, (event) => this.handleDoubleClick(event));
+        this.toggleListener('pointerdown', needsPointerDown, (event) => this.handlePointerDown(event));
+        this.toggleListener('pointerdrag', needsPointerDrag, (event) => this.handlePointerDrag(event));
+        this.toggleListener('pointerup', needsPointerUp, (event) => this.handlePointerUp(event));
+    }
+    syncNativeModify(nextState) {
+        const handled = new Set();
+        this.schema.layers.forEach((descriptor) => {
+            const interactions = descriptor.feature.interactions;
+            const modify = interactions?.modify;
+            const enabled = nextState.get(descriptor.id)?.modify ?? false;
+            const shouldEnable = !!modify && enabled;
+            if (!shouldEnable) {
+                return;
+            }
+            const entry = this.getLayerEntry(descriptor.id);
+            if (!entry) {
+                return;
+            }
+            handled.add(descriptor.id);
+            if (this.nativeModifies.has(descriptor.id)) {
+                this.nativeModifies.get(descriptor.id).interaction.setActive(true);
+                return;
+            }
+            const source = entry.layer.getSource();
+            if (!source) {
+                return;
+            }
+            const interaction = new Modify({
+                source,
+                pixelTolerance: this.getHitTolerance(modify.hitTolerance),
+                style: modify.vertexStyle,
+            });
+            const keys = [
+                interaction.on('modifystart', (event) => this.handleNativeModifyStart(entry, modify, event)),
+                interaction.on('modifyend', (event) => this.handleNativeModifyEnd(entry, modify, event)),
+            ];
+            this.map.addInteraction(interaction);
+            this.nativeModifies.set(descriptor.id, { interaction, keys });
+        });
+        Array.from(this.nativeModifies.keys()).forEach((layerId) => {
+            if (!handled.has(layerId)) {
+                this.teardownNativeModify(layerId);
+            }
+        });
+    }
+    teardownNativeModify(layerId) {
+        const entry = this.nativeModifies.get(layerId);
+        if (!entry) {
+            return;
+        }
+        entry.keys.forEach((key) => Observable.unByKey(key));
+        this.map.removeInteraction(entry.interaction);
+        this.nativeModifies.delete(layerId);
+    }
+    handleNativeModifyStart(entry, modify, event) {
+        const items = this.resolveHitItemsFromFeatures(entry, event.features);
+        if (items.length === 0) {
+            return;
+        }
+        if (modify.state) {
+            this.applyState(items, modify.state, true);
+        }
+        if (modify.onStart) {
+            this.isHandled(modify.onStart({ item: items[0], ctx: this.ctx, event }));
+        }
+    }
+    handleNativeModifyEnd(entry, modify, event) {
+        const items = this.resolveHitItemsFromFeatures(entry, event.features);
+        if (items.length === 0) {
+            return;
+        }
+        this.runInteractionMutation(() => {
+            items.forEach((item) => {
+                const geometry = item.feature.getGeometry();
+                if (!geometry) {
+                    return;
+                }
+                const id = entry.descriptor.feature.id(item.model);
+                entry.api.mutate(id, (prev) => entry.descriptor.feature.geometry.applyGeometryToModel(prev, geometry), 'modify');
+            });
+        });
+        if (modify.onEnd) {
+            this.isHandled(modify.onEnd({ item: items[0], ctx: this.ctx, event }));
+        }
+        if (modify.state) {
+            this.applyState(items, modify.state, false);
+        }
+    }
+    resolveHitItemsFromFeatures(entry, features) {
+        return features
+            .getArray()
+            .map((feature) => {
+            const model = entry.api.getModelByFeature(feature);
+            if (!model) {
+                return null;
+            }
+            return { model, feature };
+        })
+            .filter((item) => item !== null);
+    }
+    hasCursorInteraction(interactions) {
+        const candidates = [
+            interactions.hover,
+            interactions.select,
+            interactions.click,
+            interactions.doubleClick,
+            interactions.translate,
+            interactions.modify,
+        ];
+        return candidates.some((interaction) => interaction?.cursor && this.isEnabled(interaction.enabled));
+    }
+    toggleListener(type, enabled, handler) {
+        if (enabled) {
+            if (!this.listenerKeys.has(type)) {
+                const key = this.map.on(type, handler);
+                this.listenerKeys.set(type, key);
+            }
+            return;
+        }
+        this.removeListener(type);
+    }
+    removeListener(type) {
+        const key = this.listenerKeys.get(type);
+        if (key) {
+            Observable.unByKey(key);
+            this.listenerKeys.delete(type);
+        }
+    }
+    isListening(type) {
+        return this.listenerKeys.has(type);
+    }
+    applyDisabledCleanup(nextState) {
+        this.enabledState.forEach((prev, layerId) => {
+            const next = nextState.get(layerId) ?? {
+                click: false,
+                doubleClick: false,
+                hover: false,
+                select: false,
+                translate: false,
+                modify: false,
+            };
+            const entry = this.getLayerEntry(layerId);
+            if (!entry) {
+                return;
+            }
+            if (prev.hover && !next.hover) {
+                this.clearHoverState(entry);
+            }
+            if (prev.select && !next.select) {
+                this.clearSelectState(entry);
+            }
+            if (prev.translate && !next.translate) {
+                this.cancelTranslate(entry);
+            }
+            if (prev.modify && !next.modify) {
+                this.cancelModify(entry);
+            }
+        });
+        this.setCursor(undefined);
+    }
+    clearHoverState(entry) {
+        const prev = this.hoverItems.get(entry.descriptor.id);
+        if (!prev) {
+            return;
+        }
+        const hover = entry.descriptor.feature.interactions?.hover;
+        if (hover?.state) {
+            this.applyState(Array.from(prev.values()), hover.state, false);
+        }
+        this.hoverItems.delete(entry.descriptor.id);
+    }
+    clearSelectState(entry) {
+        const prev = this.selectedItems.get(entry.descriptor.id);
+        if (!prev) {
+            return;
+        }
+        const select = entry.descriptor.feature.interactions?.select;
+        if (select?.state) {
+            this.applyState(Array.from(prev.values()), select.state, false);
+        }
+        this.selectedItems.delete(entry.descriptor.id);
+    }
+    cancelTranslate(entry) {
+        const active = this.activeTranslates.get(entry.descriptor.id);
+        if (active) {
+            this.finishTranslate(entry, active, active.lastItem);
+        }
+    }
+    cancelModify(entry) {
+        const active = this.activeModifies.get(entry.descriptor.id);
+        if (active) {
+            this.finishModify(entry, active, active.lastItem);
+        }
+    }
+    updateCursor(event) {
+        const activeCursor = this.getActiveSessionCursor();
+        if (activeCursor !== undefined) {
+            this.setCursor(activeCursor ?? undefined);
+            return;
+        }
+        if (!event) {
+            this.setCursor(undefined);
+            return;
+        }
+        for (const entry of this.getOrderedLayers()) {
+            const interactions = entry.descriptor.feature.interactions;
+            if (!interactions) {
+                continue;
+            }
+            const cursor = this.getLayerCursor(interactions);
+            if (!cursor) {
+                continue;
+            }
+            const hitTolerance = this.getCursorHitTolerance(interactions);
+            const { items } = this.hitTest({
+                layerId: entry.descriptor.id,
+                layer: entry.layer,
+                api: entry.api,
+                descriptor: entry.descriptor,
+                event,
+                hitTolerance,
+            });
+            if (items.length > 0) {
+                this.setCursor(cursor);
+                return;
+            }
+        }
+        this.setCursor(undefined);
+    }
+    getActiveSessionCursor() {
+        for (const entry of this.getOrderedLayers()) {
+            const activeTranslate = this.activeTranslates.get(entry.descriptor.id);
+            if (activeTranslate) {
+                return activeTranslate.translate.cursor ?? null;
+            }
+            const activeModify = this.activeModifies.get(entry.descriptor.id);
+            if (activeModify) {
+                return activeModify.modify.cursor ?? null;
+            }
+        }
+        return undefined;
+    }
+    getLayerCursor(interactions) {
+        const candidates = [
+            interactions.hover,
+            interactions.select,
+            interactions.click,
+            interactions.doubleClick,
+            interactions.translate,
+            interactions.modify,
+        ];
+        for (const interaction of candidates) {
+            if (!interaction || !interaction.cursor) {
+                continue;
+            }
+            if (!this.isEnabled(interaction.enabled)) {
+                continue;
+            }
+            return interaction.cursor;
+        }
+        return undefined;
+    }
+    getCursorHitTolerance(interactions) {
+        const candidates = [
+            interactions.hover,
+            interactions.select,
+            interactions.click,
+            interactions.doubleClick,
+            interactions.translate,
+            interactions.modify,
+        ].filter((interaction) => interaction && interaction.cursor && this.isEnabled(interaction.enabled));
+        if (candidates.length === 0) {
+            return this.getHitTolerance(undefined);
+        }
+        const tolerances = candidates
+            .map((interaction) => interaction?.hitTolerance)
+            .filter((value) => value !== undefined);
+        if (tolerances.length === 0) {
+            return this.getHitTolerance(undefined);
+        }
+        return Math.max(...tolerances);
+    }
+    setCursor(cursor) {
+        if (this.currentCursor === cursor) {
+            return;
+        }
+        const target = this.getTargetElement();
+        if (!target) {
+            return;
+        }
+        target.style.cursor = cursor ?? '';
+        this.currentCursor = cursor;
+    }
+    getTargetElement() {
+        const targetElement = this.map.getTargetElement?.();
+        if (targetElement) {
+            return targetElement;
+        }
+        const target = this.map.getTarget?.();
+        if (!target) {
+            return null;
+        }
+        if (typeof target === 'string') {
+            if (typeof document === 'undefined') {
+                return null;
+            }
+            return document.getElementById(target);
+        }
+        return target;
+    }
+    getLayerEntry(layerId) {
+        const index = this.schema.layers.findIndex((layer) => layer.id === layerId);
+        if (index < 0) {
+            return null;
+        }
+        const descriptor = this.schema.layers[index];
+        const layer = this.layers[layerId];
+        const api = this.apis[layerId];
+        if (!layer || !api) {
+            return null;
+        }
+        return { descriptor, layer, api, index };
+    }
+    applyTranslateMove(entry, active, event) {
+        const translate = active.translate;
+        const resolved = this.resolveTarget(entry, active.targetKey);
+        if (!resolved) {
+            this.finishTranslate(entry, active, active.lastItem);
+            return;
+        }
+        const nextCoordinate = event.coordinate;
+        const delta = [
+            nextCoordinate[0] - active.lastCoordinate[0],
+            nextCoordinate[1] - active.lastCoordinate[1],
+        ];
+        active.lastCoordinate = nextCoordinate;
+        active.lastItem = resolved;
+        const geometry = resolved.feature.getGeometry();
+        if (!geometry) {
+            return;
+        }
+        const translated = geometry.clone();
+        translated.translate(delta[0], delta[1]);
+        this.runInteractionMutation(() => entry.api.mutate(active.targetKey, (prev) => entry.descriptor.feature.geometry.applyGeometryToModel(prev, translated), 'translate'));
+        if (translate.onChange) {
+            const translateEvent = this.createTranslateEvent(event, active.startCoordinate, 'translating', [resolved]);
+            active.lastHandled = this.isHandled(translate.onChange({ item: resolved, ctx: this.ctx, event: translateEvent }));
+        }
+        else {
+            active.lastHandled = false;
+        }
+    }
+    applyModifyChange(entry, active, event) {
+        const modify = active.modify;
+        const resolved = this.resolveTarget(entry, active.targetKey);
+        if (!resolved) {
+            this.finishModify(entry, active, active.lastItem);
+            return;
+        }
+        active.lastItem = resolved;
+        const geometry = resolved.feature.getGeometry();
+        if (!geometry) {
+            return;
+        }
+        const nextGeometry = geometry.clone();
+        this.runInteractionMutation(() => entry.api.mutate(active.targetKey, (prev) => entry.descriptor.feature.geometry.applyGeometryToModel(prev, nextGeometry), 'modify'));
+        if (modify.onChange) {
+            const modifyEvent = this.createModifyEvent(event, 'modifying', [resolved]);
+            active.lastHandled = this.isHandled(modify.onChange({ item: resolved, ctx: this.ctx, event: modifyEvent }));
+        }
+        else {
+            active.lastHandled = false;
+        }
+    }
+    finishTranslate(entry, active, item) {
+        const finalItem = item ?? active.lastItem;
+        if (active.throttleTimer) {
+            clearTimeout(active.throttleTimer);
+            active.throttleTimer = undefined;
+            active.pendingEvent = undefined;
+        }
+        if (active.translate.state && finalItem) {
+            this.applyState([finalItem], active.translate.state, false);
+        }
+        this.activeTranslates.delete(entry.descriptor.id);
+        this.unlockDragPan();
+    }
+    finishModify(entry, active, item) {
+        const finalItem = item ?? active.lastItem;
+        if (active.throttleTimer) {
+            clearTimeout(active.throttleTimer);
+            active.throttleTimer = undefined;
+            active.pendingEvent = undefined;
+        }
+        if (active.modify.state && finalItem) {
+            this.applyState([finalItem], active.modify.state, false);
+        }
+        this.activeModifies.delete(entry.descriptor.id);
+        this.unlockDragPan();
+    }
+    resolveTarget(entry, targetKey) {
+        const source = entry.layer.getSource();
+        if (!source) {
+            return null;
+        }
+        const resolvedSource = source instanceof ClusterSource ? source.getSource() : source;
+        if (!resolvedSource) {
+            return null;
+        }
+        const feature = resolvedSource.getFeatureById(targetKey);
+        if (!(feature instanceof Feature)) {
+            return null;
+        }
+        const model = entry.api.getModelByFeature(feature);
+        if (!model) {
+            return null;
+        }
+        return { model, feature };
+    }
+    lockDragPan() {
+        this.dragPanLocks += 1;
+        if (this.dragPanLocks !== 1) {
+            return;
+        }
+        const interactions = this.map.getInteractions?.();
+        if (!interactions) {
+            return;
+        }
+        const dragPans = interactions
+            .getArray()
+            .filter((interaction) => interaction instanceof DragPan);
+        if (dragPans.length === 0) {
+            return;
+        }
+        if (!this.dragPanStates) {
+            this.dragPanStates = new Map();
+        }
+        dragPans.forEach((interaction) => {
+            if (!this.dragPanStates?.has(interaction)) {
+                this.dragPanStates?.set(interaction, interaction.getActive());
+            }
+            interaction.setActive(false);
+        });
+    }
+    unlockDragPan() {
+        if (this.dragPanLocks === 0) {
+            return;
+        }
+        this.dragPanLocks -= 1;
+        if (this.dragPanLocks !== 0) {
+            return;
+        }
+        if (!this.dragPanStates) {
+            return;
+        }
+        this.dragPanStates.forEach((wasActive, interaction) => {
+            interaction.setActive(wasActive);
+        });
+        this.dragPanStates = undefined;
+    }
+    createTranslateEvent(event, startCoordinate, type, items) {
+        const features = new Collection(items.map((item) => item.feature));
+        return {
+            type,
+            features,
+            coordinate: event.coordinate,
+            startCoordinate,
+            mapBrowserEvent: event,
+        };
+    }
+    createModifyEvent(event, type, items) {
+        const features = new Collection(items.map((item) => item.feature));
+        return {
+            type,
+            features,
+            mapBrowserEvent: event,
+        };
+    }
+    createDefaultHitTest() {
+        return ({ layer, api, event, hitTolerance }) => {
+            const items = [];
+            let clusterHit;
+            this.map.forEachFeatureAtPixel(event.pixel, (feature) => {
+                if (!(feature instanceof Feature)) {
+                    return;
+                }
+                const clusterFeatures = getClusterFeatures(feature);
+                if (clusterFeatures) {
+                    if (clusterFeatures.length > 1) {
+                        if (!clusterHit) {
+                            clusterHit = {
+                                feature: feature,
+                                features: clusterFeatures,
+                                size: clusterFeatures.length,
+                            };
+                        }
+                        return;
+                    }
+                    const singleFeature = clusterFeatures[0];
+                    const singleModel = api.getModelByFeature(singleFeature);
+                    if (!singleModel) {
+                        return;
+                    }
+                    items.push({ model: singleModel, feature: singleFeature });
+                    return;
+                }
+                const model = api.getModelByFeature(feature);
+                if (!model) {
+                    return;
+                }
+                items.push({ model, feature });
+            }, {
+                layerFilter: (candidateLayer) => candidateLayer === layer,
+                hitTolerance,
+            });
+            return { items, cluster: clusterHit };
+        };
+    }
+    collectFeaturePopupItems(entry, items, event) {
+        const popup = entry.descriptor.feature.popup;
+        if (!popup || !this.isEnabled(popup.enabled)) {
+            return [];
+        }
+        return items.map((item) => {
+            const popupItem = popup.item({
+                model: item.model,
+                feature: item.feature,
+                ctx: this.ctx,
+                event,
+            });
+            return {
+                ...popupItem,
+                source: popupItem.source ?? 'feature',
+                dedupKey: popupItem.dedupKey ?? entry.descriptor.feature.id(item.model),
+            };
+        });
+    }
+    collectPopupItems(entry, hitResult, event) {
+        if (entry.descriptor.clustering && entry.api.isClusteringEnabled?.() && hitResult.cluster) {
+            const clustering = entry.descriptor.clustering;
+            if (clustering?.popup && this.isEnabled(clustering.popup.enabled)) {
+                const models = hitResult.cluster.features
+                    .map((clusterFeature) => entry.api.getModelByFeature(clusterFeature))
+                    .filter((model) => model !== undefined);
+                const popupItem = clustering.popup.item({
+                    models,
+                    size: hitResult.cluster.size,
+                    ctx: this.ctx,
+                    event,
+                });
+                return [
+                    {
+                        ...popupItem,
+                        source: popupItem.source ?? 'cluster',
+                        dedupKey: popupItem.dedupKey ?? this.getClusterDedupKey(entry, models),
+                    },
+                ];
+            }
+            return [];
+        }
+        return this.collectFeaturePopupItems(entry, hitResult.items, event);
+    }
+    getClusterDedupKey(entry, models) {
+        const ids = models
+            .map((model) => String(entry.descriptor.feature.id(model)))
+            .sort((a, b) => a.localeCompare(b))
+            .join('|');
+        return `cluster:${entry.descriptor.id}:${ids}`;
+    }
+    getOrderedLayers() {
+        return this.schema.layers
+            .map((descriptor, index) => ({
+            descriptor,
+            index,
+            layer: this.layers[descriptor.id],
+            api: this.apis[descriptor.id],
+        }))
+            .filter((entry) => entry.layer && entry.api)
+            .sort((a, b) => {
+            const aZ = a.layer.getZIndex() ?? 0;
+            const bZ = b.layer.getZIndex() ?? 0;
+            if (aZ !== bZ) {
+                return bZ - aZ;
+            }
+            return a.index - b.index;
+        });
+    }
+    getHitTolerance(hitTolerance) {
+        if (hitTolerance !== undefined) {
+            return hitTolerance;
+        }
+        if (this.schema.options?.hitTolerance !== undefined) {
+            return this.schema.options.hitTolerance;
+        }
+        return 0;
+    }
+    isEnabled(enabled) {
+        if (enabled === undefined) {
+            return true;
+        }
+        if (typeof enabled === 'function') {
+            return enabled();
+        }
+        return enabled;
+    }
+    processHover(entry, hover, items, event) {
+        const prev = this.hoverItems.get(entry.descriptor.id) ?? new Map();
+        const next = this.itemsToMap(entry, items);
+        const entered = Array.from(next.entries())
+            .filter(([id]) => !prev.has(id))
+            .map(([, item]) => item);
+        const left = Array.from(prev.entries())
+            .filter(([id]) => !next.has(id))
+            .map(([, item]) => item);
+        let handled = false;
+        if (left.length > 0 && hover.onLeave) {
+            handled = this.isHandled(hover.onLeave({ items: left, ctx: this.ctx, event }));
+        }
+        if (entered.length > 0 && hover.onEnter) {
+            handled = this.isHandled(hover.onEnter({ items: entered, ctx: this.ctx, event })) || handled;
+        }
+        if (hover.state) {
+            this.applyState(left, hover.state, false);
+            this.applyState(entered, hover.state, true);
+        }
+        this.hoverItems.set(entry.descriptor.id, next);
+        return handled;
+    }
+    processSelect(entry, select, items, event) {
+        if (items.length === 0) {
+            const prev = this.selectedItems.get(entry.descriptor.id);
+            this.selectedItems.set(entry.descriptor.id, new Map());
+            if (select.onClear) {
+                const handled = this.isHandled(select.onClear({ ctx: this.ctx, event }));
+                if (select.state && prev) {
+                    this.applyState(Array.from(prev.values()), select.state, false);
+                }
+                return handled;
+            }
+            if (select.state && prev) {
+                this.applyState(Array.from(prev.values()), select.state, false);
+            }
+            return false;
+        }
+        const prev = this.selectedItems.get(entry.descriptor.id) ?? new Map();
+        const next = this.itemsToMap(entry, items);
+        const handled = select.onSelect
+            ? this.isHandled(select.onSelect({ items, ctx: this.ctx, event }))
+            : false;
+        if (select.state) {
+            const added = Array.from(next.entries())
+                .filter(([id]) => !prev.has(id))
+                .map(([, item]) => item);
+            const removed = Array.from(prev.entries())
+                .filter(([id]) => !next.has(id))
+                .map(([, item]) => item);
+            this.applyState(removed, select.state, false);
+            this.applyState(added, select.state, true);
+        }
+        this.selectedItems.set(entry.descriptor.id, next);
+        return handled;
+    }
+    processClick(entry, click, items, event) {
+        if (items.length === 0) {
+            return false;
+        }
+        return this.isHandled(click.onClick({ items, ctx: this.ctx, event }));
+    }
+    processDoubleClick(entry, doubleClick, items, event) {
+        if (items.length === 0) {
+            return false;
+        }
+        return this.isHandled(doubleClick.onDoubleClick({ items, ctx: this.ctx, event }));
+    }
+    itemsToMap(entry, items) {
+        const next = new Map();
+        items.forEach((item) => {
+            const id = entry.descriptor.feature.id(item.model);
+            next.set(id, item);
+        });
+        return next;
+    }
+    applyState(items, state, enabled) {
+        const states = Array.isArray(state) ? state : [state];
+        items.forEach((item) => {
+            const current = new Set(getFeatureStates(item.feature));
+            states.forEach((entry) => {
+                if (enabled) {
+                    current.add(entry);
+                }
+                else {
+                    current.delete(entry);
+                }
+            });
+            setFeatureStates(item.feature, Array.from(current));
+        });
+    }
+    isHandled(result) {
+        return result === true;
+    }
+    shouldStopPropagation(base) {
+        return base.propagation !== 'continue';
+    }
+    shouldContinuePropagation(base) {
+        return base.propagation === 'continue';
+    }
+    handleClusterClick(entry, clusterHit, event, manualPopupPush) {
+        const clustering = entry.descriptor.clustering;
+        if (!clustering) {
+            return false;
+        }
+        const models = clusterHit.features
+            .map((clusterFeature) => entry.api.getModelByFeature(clusterFeature))
+            .filter((model) => model !== undefined);
+        let handled = false;
+        if (clustering.expandOnClick) {
+            this.expandCluster(clusterHit, clustering.expandOnClick);
+            clustering.expandOnClick.onExpanded?.({ models, ctx: this.ctx });
+            handled = true;
+        }
+        if (clustering.popup && this.isEnabled(clustering.popup.enabled)) {
+            if (manualPopupPush || !this.ctx.popupHost) {
+                const item = clustering.popup.item({ models, size: clusterHit.size, ctx: this.ctx, event });
+                if (manualPopupPush && this.ctx.popupHost) {
+                    this.ctx.popupHost.push([
+                        {
+                            ...item,
+                            source: item.source ?? 'cluster',
+                            dedupKey: item.dedupKey ?? this.getClusterDedupKey(entry, models),
+                        },
+                    ]);
+                }
+            }
+            handled = true;
+        }
+        return handled;
+    }
+    expandCluster(clusterHit, expand) {
+        const view = this.map.getView();
+        const duration = expand.durationMs;
+        if (expand.mode === 'zoomIn') {
+            const currentZoom = view.getZoom() ?? 0;
+            const delta = expand.zoomDelta ?? 1;
+            const targetZoom = currentZoom + delta;
+            const nextZoom = expand.maxZoom !== undefined ? Math.min(expand.maxZoom, targetZoom) : targetZoom;
+            view.animate({ zoom: nextZoom, duration });
+            return;
+        }
+        const extent = createEmpty();
+        clusterHit.features.forEach((feature) => {
+            const geometry = feature.getGeometry();
+            if (geometry) {
+                extend(extent, geometry.getExtent());
+            }
+        });
+        if (isEmpty(extent)) {
+            return;
+        }
+        const padding = toOlPadding(expand.padding, undefined);
+        view.fit(extent, {
+            padding,
+            duration,
+            maxZoom: expand.maxZoom,
+        });
+    }
+    shouldStopClusterPropagation() {
+        return true;
+    }
+}
+
+class StyleCache {
+    stringCache = new Map();
+    get(key) {
+        return this.stringCache.get(key);
+    }
+    set(key, value) {
+        this.stringCache.set(key, value);
+    }
+}
+
+const resolveMaybeFn = (value, args) => {
+    if (typeof value === 'function') {
+        return value(...args);
+    }
+    return value;
+};
+const applyPatch = (opts, patch) => {
+    const patchValue = typeof patch === 'function' ? patch(opts) : patch;
+    return { ...opts, ...patchValue };
+};
+const orderStates = (states, priority) => {
+    if (!priority || priority.length === 0) {
+        return states;
+    }
+    const prioritySet = new Set(priority);
+    const ordered = priority.filter((state) => states.includes(state));
+    const rest = states.filter((state) => !prioritySet.has(state));
+    return [...ordered, ...rest];
+};
+const createStyleFunction = (options) => {
+    const { descriptor, registryGetModel, map } = options;
+    const { style } = descriptor;
+    const cache = new StyleCache();
+    return (feature, resolution) => {
+        if (!(feature instanceof Feature)) {
+            return [];
+        }
+        const model = registryGetModel(feature);
+        if (!model) {
+            return [];
+        }
+        const view = {
+            resolution,
+            zoom: map?.getView().getZoom(),
+        };
+        let opts = resolveMaybeFn(style.base, [model, view]);
+        if (style.states) {
+            const featureStates = orderStates(getFeatureStates(feature), style.statePriority);
+            featureStates.forEach((state) => {
+                const patchFactory = style.states?.[state];
+                if (!patchFactory) {
+                    return;
+                }
+                const patch = resolveMaybeFn(patchFactory, [model, view]);
+                opts = applyPatch(opts, patch);
+            });
+        }
+        if (style.cacheKey) {
+            const key = style.cacheKey(opts, view);
+            if (key) {
+                const cached = cache.get(key);
+                if (cached) {
+                    return cached;
+                }
+                const rendered = style.render(opts, view);
+                cache.set(key, rendered);
+                return rendered;
+            }
+        }
+        return style.render(opts, view);
+    };
+};
+const createClusterStyleFunction = (options) => {
+    const { clustering, registryGetModel, map } = options;
+    const baseStyle = createStyleFunction(options);
+    const cache = new StyleCache();
+    return (feature, resolution) => {
+        if (!(feature instanceof Feature)) {
+            return [];
+        }
+        const clusterFeatures = getClusterFeatures(feature);
+        if (!clusterFeatures) {
+            return baseStyle(feature, resolution);
+        }
+        const size = clusterFeatures.length;
+        if (size === 1) {
+            return baseStyle(clusterFeatures[0], resolution);
+        }
+        const models = clusterFeatures
+            .map((clusterFeature) => registryGetModel(clusterFeature))
+            .filter((model) => model !== undefined);
+        const view = {
+            resolution,
+            zoom: map?.getView().getZoom(),
+        };
+        if (clustering.clusterStyle.cacheKey) {
+            const key = clustering.clusterStyle.cacheKey({ models, size, view });
+            if (key) {
+                const cached = cache.get(key);
+                if (cached) {
+                    return cached;
+                }
+                const rendered = clustering.clusterStyle.render({ models, size, view });
+                cache.set(key, rendered);
+                return rendered;
+            }
+        }
+        return clustering.clusterStyle.render({ models, size, view });
+    };
+};
+
+class FeatureRegistry {
+    idToModel = new Map();
+    idToFeature = new Map();
+    featureToId = new WeakMap();
+    set(id, model, feature) {
+        this.idToModel.set(id, model);
+        this.idToFeature.set(id, feature);
+        this.featureToId.set(feature, id);
+    }
+    updateModel(id, model) {
+        if (!this.idToModel.has(id)) {
+            return;
+        }
+        this.idToModel.set(id, model);
+    }
+    getModel(id) {
+        return this.idToModel.get(id);
+    }
+    getFeature(id) {
+        return this.idToFeature.get(id);
+    }
+    getIdByFeature(feature) {
+        return this.featureToId.get(feature);
+    }
+    getModelByFeature(feature) {
+        const id = this.featureToId.get(feature);
+        if (id === undefined) {
+            return undefined;
+        }
+        return this.idToModel.get(id);
+    }
+    has(id) {
+        return this.idToModel.has(id);
+    }
+    remove(id) {
+        const feature = this.idToFeature.get(id);
+        if (!feature) {
+            return undefined;
+        }
+        this.idToModel.delete(id);
+        this.idToFeature.delete(id);
+        this.featureToId.delete(feature);
+        return feature;
+    }
+    forEachId(fn) {
+        this.idToModel.forEach((_model, id) => fn(id));
+    }
+}
+
+class VectorLayerBase {
+    descriptor;
+    layer;
+    source;
+    registry = new FeatureRegistry();
+    scheduleInvalidate;
+    ctx;
+    changeHandlers = new Set();
+    constructor(options) {
+        this.descriptor = options.descriptor.feature;
+        this.layer = options.layer;
+        this.source = options.source;
+        this.ctx = options.ctx;
+        this.scheduleInvalidate = options.scheduleInvalidate;
+    }
+    setModels(models) {
+        this.setModelsInternal(models);
+    }
+    invalidate() {
+        this.scheduleInvalidate();
+    }
+    syncFeatureFromModel(model) {
+        const id = this.descriptor.id(model);
+        const feature = this.registry.getFeature(id);
+        if (!feature) {
+            return;
+        }
+        feature.setGeometry(this.descriptor.geometry.fromModel(model));
+    }
+    getModelByFeature(feature) {
+        return this.registry.getModelByFeature(feature);
+    }
+    mutate(id, update, reason = 'mutate') {
+        const prev = this.registry.getModel(id);
+        if (!prev) {
+            return;
+        }
+        const next = update(prev);
+        if (next === prev) {
+            return;
+        }
+        this.registry.updateModel(id, next);
+        this.syncFeatureFromModel(next);
+        this.scheduleInvalidate();
+        this.emitModelChanges([{ prev, next, reason }]);
+    }
+    mutateMany(ids, update, reason = 'mutate') {
+        const changes = [];
+        ids.forEach((id) => {
+            const prev = this.registry.getModel(id);
+            if (!prev) {
+                return;
+            }
+            const next = update(prev);
+            if (next === prev) {
+                return;
+            }
+            this.registry.updateModel(id, next);
+            this.syncFeatureFromModel(next);
+            changes.push({ prev, next, reason });
+        });
+        if (changes.length === 0) {
+            return;
+        }
+        this.scheduleInvalidate();
+        this.emitModelChanges(changes);
+    }
+    onModelsChanged(cb) {
+        this.changeHandlers.add(cb);
+        return () => this.changeHandlers.delete(cb);
+    }
+    /** Fit view to all features on the layer. No-op if extent is empty. */
+    centerOnAllModels(opts) {
+        const current = this.getCenterOnAllModelsSource();
+        const extent = current?.getExtent?.();
+        if (!extent || isEmpty(extent)) {
+            return;
+        }
+        this.ctx.map.getView().fit(extent, toOlFitOptions(opts));
+    }
+    /** Fit view to a single feature by id. No-op if feature/geometry is missing. */
+    centerOnModel(id, opts) {
+        const feature = this.registry.getFeature(id);
+        const geom = feature?.getGeometry();
+        if (!geom) {
+            return;
+        }
+        this.ctx.map.getView().fit(geom.getExtent(), toOlFitOptions(opts));
+    }
+    /**
+     * Fit view to a subset of features by ids (combined extent).
+     * Missing ids are ignored. No-op if none found.
+     */
+    centerOnModels(ids, opts) {
+        const extent = createEmpty();
+        let found = false;
+        for (const id of ids) {
+            const feature = this.registry.getFeature(id);
+            const geom = feature?.getGeometry();
+            if (!geom)
+                continue;
+            extend(extent, geom.getExtent());
+            found = true;
+        }
+        if (!found || isEmpty(extent)) {
+            return;
+        }
+        this.ctx.map.getView().fit(extent, toOlFitOptions(opts));
+    }
+    setVisible(visible) {
+        this.layer.setVisible(visible);
+    }
+    isVisible() {
+        return this.layer.getVisible();
+    }
+    setOpacity(opacity) {
+        this.layer.setOpacity(opacity);
+    }
+    getOpacity() {
+        return this.layer.getOpacity();
+    }
+    getZIndex() {
+        return this.layer.getZIndex();
+    }
+    setZIndex(z) {
+        this.layer.setZIndex(z);
+    }
+    getModelById(id) {
+        return this.registry.getModel(id);
+    }
+    hasModel(id) {
+        return this.registry.getFeature(id) != null;
+    }
+    getAllModels() {
+        const out = [];
+        this.registry.forEachId((id) => {
+            const model = this.registry.getModel(id);
+            if (model !== undefined) {
+                out.push(model);
+            }
+        });
+        return out;
+    }
+    getAllModelIds() {
+        const out = [];
+        this.registry.forEachId((id) => out.push(id));
+        return out;
+    }
+    setFeatureStates(ids, states) {
+        const targetIds = Array.isArray(ids) ? ids : [ids];
+        const nextStates = states ? (Array.isArray(states) ? states : [states]) : [];
+        targetIds.forEach((id) => {
+            const feature = this.registry.getFeature(id);
+            if (feature) {
+                setFeatureStates(feature, nextStates);
+            }
+        });
+        this.scheduleInvalidate();
+    }
+    setModelsInternal(models) {
+        const nextIds = new Set();
+        models.forEach((model) => {
+            const id = this.descriptor.id(model);
+            nextIds.add(id);
+            const existingFeature = this.registry.getFeature(id);
+            if (existingFeature) {
+                const prevModel = this.registry.getModel(id);
+                if (prevModel !== model) {
+                    this.registry.updateModel(id, model);
+                    existingFeature.setGeometry(this.descriptor.geometry.fromModel(model));
+                }
+                return;
+            }
+            const feature = new Feature({
+                geometry: this.descriptor.geometry.fromModel(model),
+            });
+            feature.setId(id);
+            this.registry.set(id, model, feature);
+            this.source.addFeature(feature);
+            this.descriptor.geometry.onCreate?.({ feature, model, ctx: this.ctx });
+        });
+        const toRemove = [];
+        this.registry.forEachId((id) => {
+            if (!nextIds.has(id)) {
+                toRemove.push(id);
+            }
+        });
+        toRemove.forEach((id) => {
+            const feature = this.registry.remove(id);
+            if (feature) {
+                this.source.removeFeature(feature);
+            }
+        });
+    }
+    getCenterOnAllModelsSource() {
+        return this.source;
+    }
+    emitModelChanges(changes) {
+        if (changes.length === 0) {
+            return;
+        }
+        this.changeHandlers.forEach((handler) => handler(changes));
+    }
+}
+
+class ClusteredVectorLayer extends VectorLayerBase {
+    clusterSource;
+    clusteringEnabled;
+    constructor(options) {
+        super(options);
+        this.clusterSource = options.clusterSource;
+        this.clusteringEnabled = options.descriptor.clustering?.enabledByDefault ?? false;
+        this.layer.setStyle(createClusterStyleFunction({
+            descriptor: this.descriptor,
+            clustering: options.descriptor.clustering,
+            ctx: this.ctx,
+            registryGetModel: (feature) => this.registry.getModelByFeature(feature),
+            map: this.ctx.map,
+        }));
+        this.layer.setSource(this.clusteringEnabled ? this.clusterSource : this.source);
+    }
+    setModels(models) {
+        this.setModelsInternal(models);
+        this.scheduleInvalidate();
+    }
+    setClusteringEnabled(enabled) {
+        if (this.clusteringEnabled === enabled) {
+            return;
+        }
+        this.clusteringEnabled = enabled;
+        this.clearInteractionStates();
+        this.layer.setSource(enabled ? this.clusterSource : this.source);
+        if (enabled) {
+            const view = this.ctx.map.getView();
+            const resolution = view.getResolution() ?? 1;
+            this.clusterSource.loadFeatures(createEmpty(), resolution, view.getProjection());
+            this.clusterSource.refresh();
+        }
+        this.scheduleInvalidate();
+    }
+    isClusteringEnabled() {
+        return this.clusteringEnabled;
+    }
+    clearInteractionStates() {
+        this.registry.forEachId((id) => {
+            const feature = this.registry.getFeature(id);
+            if (feature) {
+                clearFeatureStates(feature);
+            }
+        });
+    }
+    getCenterOnAllModelsSource() {
+        return this.layer.getSource();
+    }
+}
+
+class PlainVectorLayer extends VectorLayerBase {
+    constructor(options) {
+        super(options);
+        this.layer.setStyle(createStyleFunction({
+            descriptor: this.descriptor,
+            ctx: this.ctx,
+            registryGetModel: (feature) => this.registry.getModelByFeature(feature),
+            map: this.ctx.map,
+        }));
+    }
+}
+
+class PopupHost {
+    options;
+    items = [];
+    container = null;
+    target = null;
+    constructor(options = {}) {
+        this.options = options;
+        if (options.mount) {
+            this.mount(options.mount);
+        }
+    }
+    push(items) {
+        if (!this.ensureEnabled()) {
+            return;
+        }
+        this.items = this.prepareItems([...this.items, ...items]);
+        this.render();
+    }
+    set(items) {
+        if (!this.ensureEnabled()) {
+            return;
+        }
+        this.items = this.prepareItems(items);
+        this.render();
+    }
+    clear() {
+        if (!this.ensureEnabled()) {
+            return;
+        }
+        this.items = [];
+        this.render();
+    }
+    remove(key) {
+        if (!this.ensureEnabled()) {
+            return;
+        }
+        this.items = this.items.filter((item) => this.getDedupKey(item) !== key);
+        this.render();
+    }
+    getItems() {
+        if (!this.isEnabled()) {
+            return [];
+        }
+        return [...this.items];
+    }
+    mount(target) {
+        if (!this.ensureEnabled()) {
+            return;
+        }
+        const element = typeof target === 'function' ? target() : target;
+        if (!element) {
+            return;
+        }
+        if (this.target !== element) {
+            this.unmount();
+        }
+        this.target = element;
+        this.render();
+    }
+    dispose() {
+        this.unmount();
+        this.items = [];
+    }
+    ensureEnabled() {
+        if (this.isEnabled()) {
+            return true;
+        }
+        this.items = [];
+        this.unmount();
+        return false;
+    }
+    isEnabled() {
+        const enabled = this.options.enabled;
+        if (enabled === undefined) {
+            return true;
+        }
+        return typeof enabled === 'function' ? enabled() : enabled;
+    }
+    unmount() {
+        if (this.container && this.container.parentElement) {
+            this.container.parentElement.removeChild(this.container);
+        }
+        this.container = null;
+        this.target = null;
+    }
+    prepareItems(items) {
+        const deduped = this.dedup(items);
+        const sorted = this.applySort(deduped);
+        return this.applyLimit(sorted);
+    }
+    dedup(items) {
+        const result = [];
+        const indices = new Map();
+        items.forEach((item) => {
+            const key = this.getDedupKey(item);
+            if (key === undefined) {
+                result.push(item);
+                return;
+            }
+            const existingIndex = indices.get(key);
+            if (existingIndex !== undefined) {
+                result[existingIndex] = item;
+                return;
+            }
+            indices.set(key, result.length);
+            result.push(item);
+        });
+        return result;
+    }
+    applySort(items) {
+        const comparator = this.options.sort ?? this.defaultSort;
+        const withIndex = items.map((item, index) => ({ item, index }));
+        withIndex.sort((a, b) => {
+            const result = comparator(a.item, b.item);
+            if (result !== 0) {
+                return result;
+            }
+            return a.index - b.index;
+        });
+        return withIndex.map((entry) => entry.item);
+    }
+    applyLimit(items) {
+        if (this.options.maxItems === undefined) {
+            return items;
+        }
+        return items.slice(0, this.options.maxItems);
+    }
+    getDedupKey(item) {
+        if (item.dedupKey !== undefined) {
+            return item.dedupKey;
+        }
+        const model = item.model;
+        if (model && (typeof model.id === 'string' || typeof model.id === 'number')) {
+            return model.id;
+        }
+        return undefined;
+    }
+    defaultSort(a, b) {
+        const aPriority = a.priority ?? 0;
+        const bPriority = b.priority ?? 0;
+        return bPriority - aPriority;
+    }
+    render() {
+        if (!this.target) {
+            return;
+        }
+        if (!this.container) {
+            this.container = document.createElement('div');
+            this.container.className = 'mf-popup-host';
+            this.target.appendChild(this.container);
+        }
+        this.container.innerHTML = '';
+        this.items.forEach((item) => {
+            const card = document.createElement('div');
+            card.className = 'mf-popup-item';
+            if (item.className) {
+                card.classList.add(item.className);
+            }
+            if (typeof item.content === 'string') {
+                card.textContent = item.content;
+            }
+            else {
+                card.appendChild(item.content);
+            }
+            const key = this.getDedupKey(item);
+            if (key !== undefined) {
+                const close = document.createElement('button');
+                close.type = 'button';
+                close.dataset['popupClose'] = String(key);
+                close.textContent = '×';
+                close.addEventListener('click', () => this.remove(key));
+                card.appendChild(close);
+            }
+            this.container.appendChild(card);
+        });
+    }
+}
+
+class LayerManager {
+    map;
+    layers = {};
+    apis = {};
+    interactions;
+    ctx;
+    constructor(map, schema) {
+        this.map = map;
+        const popupHost = schema.options?.popupHost ? new PopupHost(schema.options.popupHost) : undefined;
+        const scheduler = new FlushScheduler(schema.options?.scheduler?.policy ?? 'microtask');
+        const ctx = createMapContext(this.map, this.apis, popupHost, scheduler);
+        this.ctx = ctx;
+        schema.layers.forEach((descriptor) => {
+            const source = new VectorSource();
+            const clusterSource = descriptor.clustering
+                ? new ClusterSource({
+                    source,
+                    distance: descriptor.clustering.distance,
+                })
+                : null;
+            const layer = new VectorLayer({ source });
+            if (descriptor.zIndex !== undefined) {
+                layer.setZIndex(descriptor.zIndex);
+            }
+            if (descriptor.visibleByDefault !== undefined) {
+                layer.setVisible(descriptor.visibleByDefault);
+            }
+            if (descriptor.title) {
+                layer.set('title', descriptor.title);
+            }
+            layer.set('id', descriptor.id);
+            const scheduleInvalidate = () => scheduler.schedule(layer, () => layer.changed());
+            const api = descriptor.clustering
+                ? new ClusteredVectorLayer({
+                    descriptor,
+                    layer,
+                    source,
+                    clusterSource: clusterSource,
+                    ctx,
+                    scheduleInvalidate,
+                })
+                : new PlainVectorLayer({
+                    descriptor,
+                    layer,
+                    source,
+                    ctx,
+                    scheduleInvalidate,
+                });
+            this.layers[descriptor.id] = layer;
+            this.apis[descriptor.id] = api;
+            this.map.addLayer(layer);
+        });
+        this.interactions = new InteractionManager({
+            ctx,
+            map: this.map,
+            schema,
+            layers: this.layers,
+            apis: this.apis,
+        });
+    }
+    static create(map, schema) {
+        return new LayerManager(map, schema);
+    }
+    getLayer(id) {
+        return this.layers[id];
+    }
+    getApi(id) {
+        return this.apis[id];
+    }
+    getApis() {
+        return { ...this.apis };
+    }
+    getContext() {
+        return this.ctx;
+    }
+    refreshEnabled() {
+        this.interactions.refreshEnabled();
+    }
+}
+
+/*
+ * Public API Surface of lib
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { LayerManager, LibComponent, LibService };
+//# sourceMappingURL=aur-openlayers.mjs.map