@geoit/ui 0.0.4 → 0.0.5

package/esm2022/lib/figma/geo-map/services/geo-map.service.mjs

@@ -0,0 +1,540 @@
+import { Injectable, inject } from '@angular/core';
+import OlMap from 'ol/Map';
+import View from 'ol/View';
+import { defaults as defaultControls } from 'ol/control/defaults';
+import ScaleLine from 'ol/control/ScaleLine';
+import MousePosition from 'ol/control/MousePosition';
+import { createStringXY } from 'ol/coordinate';
+import { unByKey } from 'ol/Observable';
+import GeoJSON from 'ol/format/GeoJSON';
+import VectorLayer from 'ol/layer/Vector';
+import VectorSource from 'ol/source/Vector';
+import { transformExtent } from 'ol/proj';
+import { Fill, Icon, Stroke, Style } from 'ol/style';
+import { GEO_MAP_BASEMAP_LAYER_ID, GEO_MAP_DEFAULT_MAX_ZOOM, GEO_MAP_DEFAULT_PROVINCE_EXTENT_4326, GEO_MAP_HIGHLIGHT_LAYER_ID, } from '../geo-map.constants';
+import { GeoMapLayerService, } from './geo-map-layer.service';
+import { GeoMapProjectionService } from './geo-map-projection.service';
+import * as i0 from "@angular/core";
+/**
+ * Owns a single OpenLayers Map instance for the providing component injector.
+ * Do not put Map/Layer objects into Angular template state.
+ */
+export class GeoMapService {
+    layerService = inject(GeoMapLayerService);
+    projection = inject(GeoMapProjectionService);
+    map = null;
+    managedLayers = new Map();
+    listenerKeys = [];
+    resizeObserver = null;
+    resizeCleanup = null;
+    activeBasemapId = GEO_MAP_BASEMAP_LAYER_ID;
+    highlightLayer = null;
+    highlightSource = null;
+    getMap() {
+        return this.map;
+    }
+    isInitialized() {
+        return this.map != null;
+    }
+    init(options) {
+        if (this.map) {
+            console.warn('[GeoMapService] Map already initialized; returning existing instance.');
+            return this.map;
+        }
+        if (!options.target) {
+            throw new Error('Map target element is required.');
+        }
+        const { width, height } = options.target.getBoundingClientRect();
+        if (width === 0 || height === 0) {
+            console.warn('[GeoMapService] Map container has zero size; call updateSize() after layout.');
+        }
+        this.projection.ensureRegistered(options.viewProjection);
+        const controls = defaultControls({
+            zoom: options.showZoomControl !== false,
+            rotate: false,
+            attribution: false,
+        }).extend([new ScaleLine({ units: 'metric' })]);
+        if (options.showMousePosition) {
+            const mouseProj = options.mousePositionProjection ?? 'EPSG:4326';
+            this.projection.ensureRegistered(mouseProj);
+            controls.push(new MousePosition({
+                coordinateFormat: createStringXY(mouseProj === 'EPSG:4326' ? 6 : 2),
+                projection: mouseProj,
+                className: 'geo-map__mouse-position',
+                placeholder: '',
+            }));
+        }
+        const view = new View({
+            center: options.center,
+            zoom: options.zoom,
+            minZoom: options.minZoom,
+            maxZoom: options.maxZoom,
+            projection: options.viewProjection,
+        });
+        this.map = new OlMap({
+            target: options.target,
+            view,
+            controls,
+            layers: [],
+        });
+        if (options.basemap != null) {
+            const basemapCreated = this.layerService.createFromBasemapInput(options.basemap);
+            this.addManagedLayer(basemapCreated);
+            this.activeBasemapId = basemapCreated.id;
+        }
+        this.syncLayers(options.layers ?? [], { replaceBasemapShortcut: false });
+        this.observeResize(options.target);
+        // Ensure correct canvas size after paint
+        queueMicrotask(() => this.updateSize());
+        return this.map;
+    }
+    /**
+     * Sync layer stack with configs. Preserves OL layers when only visibility/opacity change.
+     */
+    syncLayers(configs, options) {
+        if (!this.map) {
+            return;
+        }
+        const nextIds = new Set(configs.map((c) => c.id));
+        if (options?.replaceBasemapShortcut === false) {
+            // Keep existing basemap shortcut layer unless configs include it.
+        }
+        // Remove obsolete (except reserved basemap shortcut when not in configs)
+        for (const [id, managed] of this.managedLayers) {
+            const keepBasemap = id === GEO_MAP_BASEMAP_LAYER_ID &&
+                options?.replaceBasemapShortcut === false &&
+                !nextIds.has(id);
+            if (!nextIds.has(id) && !keepBasemap) {
+                this.map.removeLayer(managed.layer);
+                this.managedLayers.delete(id);
+            }
+        }
+        // Sort by zIndex for predictable stacking
+        const sorted = [...configs].sort((a, b) => (a.zIndex ?? 0) - (b.zIndex ?? 0));
+        for (const config of sorted) {
+            const existing = this.managedLayers.get(config.id);
+            if (!existing) {
+                const created = this.layerService.createLayer(config);
+                this.addManagedLayer(created);
+                continue;
+            }
+            if (this.layerService.needsRecreate(existing.config, config)) {
+                this.map.removeLayer(existing.layer);
+                const created = this.layerService.createLayer(config);
+                this.addManagedLayer(created);
+            }
+            else {
+                this.layerService.patchLayer(existing.layer, config);
+                existing.config = config;
+            }
+        }
+        this.enforceSingleBasemap();
+    }
+    setLayerVisibility(layerId, visible) {
+        const managed = this.managedLayers.get(layerId);
+        if (!managed || !this.map) {
+            return;
+        }
+        if (managed.config.basemap && visible) {
+            this.activeBasemapId = layerId;
+            this.layerService.resolveBasemapExclusive([...this.managedLayers.values()], this.activeBasemapId);
+            return;
+        }
+        if (managed.config.basemap && !visible) {
+            // Keep at least one basemap if possible
+            const otherBasemap = [...this.managedLayers.values()].find((item) => item.config.basemap && item.id !== layerId);
+            if (otherBasemap) {
+                this.activeBasemapId = otherBasemap.id;
+                this.layerService.resolveBasemapExclusive([...this.managedLayers.values()], this.activeBasemapId);
+            }
+            return;
+        }
+        this.layerService.setVisible(managed.layer, visible);
+        managed.config = { ...managed.config, visible };
+    }
+    setLayerOpacity(layerId, opacity) {
+        const managed = this.managedLayers.get(layerId);
+        if (!managed) {
+            return;
+        }
+        this.layerService.setOpacity(managed.layer, opacity);
+        managed.config = { ...managed.config, opacity };
+    }
+    getManagedLayers() {
+        return [...this.managedLayers.values()];
+    }
+    setCenter(center, zoom) {
+        const view = this.map?.getView();
+        if (!view) {
+            return;
+        }
+        const current = view.getCenter();
+        const sameCenter = current != null &&
+            current.length >= 2 &&
+            Math.abs(current[0] - center[0]) < 1e-6 &&
+            Math.abs(current[1] - center[1]) < 1e-6;
+        if (!sameCenter) {
+            view.setCenter(center);
+        }
+        if (zoom != null) {
+            this.setZoom(zoom);
+        }
+    }
+    setZoom(zoom) {
+        const view = this.map?.getView();
+        if (!view) {
+            return;
+        }
+        const current = view.getZoom();
+        if (current != null && Math.abs(current - zoom) < 1e-6) {
+            return;
+        }
+        view.setZoom(zoom);
+    }
+    getZoom() {
+        return this.map?.getView().getZoom() ?? undefined;
+    }
+    zoomBy(delta) {
+        const view = this.map?.getView();
+        if (!view) {
+            return;
+        }
+        const zoom = view.getZoom();
+        if (zoom == null) {
+            return;
+        }
+        const next = Math.min(view.getMaxZoom() ?? GEO_MAP_DEFAULT_MAX_ZOOM, Math.max(view.getMinZoom() ?? 0, zoom + delta));
+        view.animate({ zoom: next, duration: 180 });
+    }
+    /** Replace the shortcut basemap layer (`GEO_MAP_BASEMAP_LAYER_ID`). */
+    setBasemap(basemap) {
+        if (!this.map) {
+            return;
+        }
+        const existing = this.managedLayers.get(GEO_MAP_BASEMAP_LAYER_ID);
+        if (existing) {
+            this.map.removeLayer(existing.layer);
+            this.managedLayers.delete(GEO_MAP_BASEMAP_LAYER_ID);
+        }
+        const created = this.layerService.createFromBasemapInput(basemap);
+        this.addManagedLayer(created);
+        this.activeBasemapId = created.id;
+        this.enforceSingleBasemap();
+        // Basemap should sit under overlays
+        created.layer.setZIndex(created.config.zIndex ?? 0);
+    }
+    fitExtent(extent, options) {
+        const view = this.map?.getView();
+        if (!view) {
+            return;
+        }
+        view.fit(extent, {
+            padding: options?.padding ?? [48, 48, 48, 48],
+            maxZoom: options?.maxZoom ?? 14,
+            duration: options?.duration ?? 250,
+        });
+    }
+    /** Fit lon/lat extent (EPSG:4326) after transforming to the active view projection. */
+    fitLonLatExtent(extent4326, options) {
+        const map = this.map;
+        if (!map) {
+            return;
+        }
+        const viewProj = map.getView().getProjection().getCode();
+        const extent = transformExtent(extent4326, 'EPSG:4326', viewProj);
+        this.fitExtent(extent, options);
+    }
+    /**
+     * Fit the default (or provided) province extent — TCQH.14 “xem toàn tỉnh”.
+     * Distinct from browser fullscreen (TCQH.15).
+     */
+    fitProvince(extent4326 = GEO_MAP_DEFAULT_PROVINCE_EXTENT_4326, options) {
+        this.fitLonLatExtent([...extent4326], {
+            maxZoom: 11,
+            duration: 400,
+            padding: [56, 56, 56, 56],
+            ...options,
+        });
+    }
+    /**
+     * Highlight search / select results (TCQH.7–12). Pass GeoJSON Feature or FeatureCollection.
+     */
+    setHighlightFromGeoJson(data, options) {
+        const map = this.map;
+        if (!map) {
+            return;
+        }
+        this.ensureHighlightLayer();
+        const viewProj = map.getView().getProjection().getCode();
+        const format = new GeoJSON();
+        let features = [];
+        try {
+            features = format.readFeatures(data, {
+                dataProjection: options?.dataProjection ?? 'EPSG:4326',
+                featureProjection: viewProj,
+            });
+        }
+        catch (err) {
+            console.error('[GeoMapService] Invalid highlight GeoJSON', err);
+            return;
+        }
+        this.setHighlightFeatures(features, options);
+    }
+    setHighlightFeatures(features, options) {
+        if (!this.map) {
+            return;
+        }
+        this.ensureHighlightLayer();
+        this.highlightSource?.clear();
+        if (features.length) {
+            this.highlightSource?.addFeatures(features);
+        }
+        const shouldFit = options?.fit !== false && features.length > 0;
+        if (shouldFit && this.highlightSource) {
+            const extent = this.highlightSource.getExtent();
+            if (extent &&
+                Number.isFinite(extent[0]) &&
+                Number.isFinite(extent[1]) &&
+                Number.isFinite(extent[2]) &&
+                Number.isFinite(extent[3])) {
+                this.fitExtent(extent, {
+                    maxZoom: 17,
+                    duration: 280,
+                    ...options?.fitOptions,
+                });
+            }
+        }
+    }
+    clearHighlight() {
+        this.highlightSource?.clear();
+    }
+    updateSize() {
+        this.map?.updateSize();
+    }
+    onClick(handler) {
+        const map = this.map;
+        if (!map) {
+            return () => undefined;
+        }
+        const key = map.on('singleclick', (evt) => {
+            const coordinate = evt.coordinate;
+            const lonLat = this.projection.transformCoordinate(coordinate, map.getView().getProjection().getCode(), 'EPSG:4326');
+            handler({
+                coordinate: [...coordinate],
+                lonLat,
+                pixel: [evt.pixel[0], evt.pixel[1]],
+                originalEvent: evt.originalEvent,
+            });
+        });
+        this.listenerKeys.push(key);
+        return () => {
+            unByKey(key);
+            this.listenerKeys = this.listenerKeys.filter((k) => k !== key);
+        };
+    }
+    /**
+     * Emit after the view settles (`moveend`), not on every resolution tick —
+     * continuous emitters flood Storybook Actions / host bindings and cause UI flicker.
+     */
+    onViewChange(handler) {
+        const map = this.map;
+        if (!map) {
+            return () => undefined;
+        }
+        const view = map.getView();
+        const emit = () => {
+            handler({
+                center: [...(view.getCenter() ?? [0, 0])],
+                zoom: view.getZoom() ?? 0,
+                resolution: view.getResolution() ?? 0,
+                rotation: view.getRotation(),
+            });
+        };
+        const key = map.on('moveend', emit);
+        this.listenerKeys.push(key);
+        return () => {
+            unByKey(key);
+            this.listenerKeys = this.listenerKeys.filter((k) => k !== key);
+        };
+    }
+    /**
+     * Tear down map, listeners, and resize observer. Safe to call multiple times.
+     */
+    destroy() {
+        unByKey(this.listenerKeys);
+        this.listenerKeys = [];
+        this.resizeCleanup?.();
+        this.resizeCleanup = null;
+        this.resizeObserver = null;
+        if (this.highlightLayer && this.map) {
+            this.map.removeLayer(this.highlightLayer);
+        }
+        this.highlightLayer = null;
+        this.highlightSource = null;
+        if (this.map) {
+            this.map.setTarget(undefined);
+            this.map.dispose();
+            this.map = null;
+        }
+        this.managedLayers.clear();
+    }
+    ensureHighlightLayer() {
+        const map = this.map;
+        if (!map) {
+            return;
+        }
+        if (this.highlightLayer && this.highlightSource) {
+            return;
+        }
+        this.highlightSource = new VectorSource();
+        this.highlightLayer = new VectorLayer({
+            source: this.highlightSource,
+            properties: { geoLayerId: GEO_MAP_HIGHLIGHT_LAYER_ID },
+            style: this.createHighlightStyle(),
+            zIndex: 450,
+            updateWhileAnimating: true,
+            updateWhileInteracting: true,
+        });
+        map.addLayer(this.highlightLayer);
+    }
+    createHighlightStyle() {
+        const stroke = this.cssColor('--geo-color-warning-default', '#f59e0b');
+        const fill = this.cssColor('--geo-color-warning-default', '#f59e0b', 0.22);
+        const pin = this.cssColor('--geo-color-error-default', '#dc2626');
+        const pinIcon = this.createPinIconDataUri(pin);
+        const areaStyle = new Style({
+            fill: new Fill({ color: fill }),
+            stroke: new Stroke({
+                color: stroke,
+                width: 3,
+            }),
+        });
+        const pointStyle = new Style({
+            image: new Icon({
+                anchor: [0.5, 1],
+                anchorXUnits: 'fraction',
+                anchorYUnits: 'fraction',
+                src: pinIcon,
+                scale: 1,
+            }),
+        });
+        return (feature) => {
+            const type = feature.getGeometry()?.getType();
+            if (type === 'Point' || type === 'MultiPoint') {
+                return pointStyle;
+            }
+            return areaStyle;
+        };
+    }
+    /** Inline SVG map pin for clicked / selected points. */
+    createPinIconDataUri(color) {
+        const svg = `
+      <svg xmlns="http://www.w3.org/2000/svg" width="32" height="40" viewBox="0 0 32 40">
+        <path fill="${color}" stroke="#ffffff" stroke-width="1.75"
+          d="M16 1C9.373 1 4 6.373 4 13c0 8.284 12 26 12 26s12-17.716 12-26C28 6.373 22.627 1 16 1z"/>
+        <circle cx="16" cy="13" r="4.5" fill="#ffffff"/>
+      </svg>
+    `.trim();
+        return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+    }
+    /** Resolve a design token for OpenLayers canvas styles. */
+    cssColor(token, fallback, alpha) {
+        if (typeof document === 'undefined') {
+            return alpha == null ? fallback : this.withAlpha(fallback, alpha);
+        }
+        const raw = getComputedStyle(document.documentElement)
+            .getPropertyValue(token)
+            .trim();
+        const color = raw || fallback;
+        return alpha == null ? color : this.withAlpha(color, alpha);
+    }
+    withAlpha(color, alpha) {
+        if (color.startsWith('rgba(') || color.startsWith('hsla(')) {
+            return color;
+        }
+        if (color.startsWith('rgb(')) {
+            return color.replace('rgb(', 'rgba(').replace(')', `, ${alpha})`);
+        }
+        if (color.startsWith('#')) {
+            const hex = color.slice(1);
+            const full = hex.length === 3
+                ? hex
+                    .split('')
+                    .map((c) => c + c)
+                    .join('')
+                : hex;
+            if (full.length !== 6) {
+                return color;
+            }
+            const r = parseInt(full.slice(0, 2), 16);
+            const g = parseInt(full.slice(2, 4), 16);
+            const b = parseInt(full.slice(4, 6), 16);
+            return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+        }
+        return color;
+    }
+    addManagedLayer(created) {
+        if (!this.map) {
+            return;
+        }
+        this.managedLayers.set(created.id, created);
+        this.map.addLayer(created.layer);
+    }
+    enforceSingleBasemap() {
+        const basemaps = [...this.managedLayers.values()].filter((item) => item.config.basemap);
+        if (basemaps.length === 0) {
+            return;
+        }
+        const active = basemaps.find((item) => item.id === this.activeBasemapId && (item.config.visible ?? true)) ??
+            basemaps.find((item) => item.config.visible ?? true) ??
+            basemaps[0];
+        this.activeBasemapId = active.id;
+        this.layerService.resolveBasemapExclusive(basemaps, this.activeBasemapId);
+    }
+    observeResize(target) {
+        if (typeof ResizeObserver === 'undefined') {
+            return;
+        }
+        let lastWidth = -1;
+        let lastHeight = -1;
+        let rafId = null;
+        this.resizeObserver = new ResizeObserver((entries) => {
+            const rect = entries[0]?.contentRect;
+            if (!rect) {
+                return;
+            }
+            const width = Math.round(rect.width);
+            const height = Math.round(rect.height);
+            if (width === 0 || height === 0) {
+                return;
+            }
+            if (width === lastWidth && height === lastHeight) {
+                return;
+            }
+            lastWidth = width;
+            lastHeight = height;
+            if (rafId != null) {
+                cancelAnimationFrame(rafId);
+            }
+            rafId = requestAnimationFrame(() => {
+                rafId = null;
+                this.updateSize();
+            });
+        });
+        this.resizeObserver.observe(target);
+        this.resizeCleanup = () => {
+            if (rafId != null) {
+                cancelAnimationFrame(rafId);
+                rafId = null;
+            }
+            this.resizeObserver?.disconnect();
+            this.resizeObserver = null;
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GeoMapService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GeoMapService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GeoMapService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geo-map.service.js","sourceRoot":"","sources":["../../../../../../../projects/geo-ui/src/lib/figma/geo-map/services/geo-map.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,MAAM,QAAQ,CAAC;AAC3B,OAAO,IAAI,MAAM,SAAS,CAAC;AAE3B,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,SAAS,MAAM,sBAAsB,CAAC;AAC7C,OAAO,aAAa,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAIxC,OAAO,OAAO,MAAM,mBAAmB,CAAC;AACxC,OAAO,WAAW,MAAM,iBAAiB,CAAC;AAC1C,OAAO,YAAY,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAErD,OAAO,EACL,wBAAwB,EACxB,wBAAwB,EACxB,oCAAoC,EACpC,0BAA0B,GAC3B,MAAM,sBAAsB,CAAC;AAS9B,OAAO,EAEL,kBAAkB,GACnB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;;AAYvE;;;GAGG;AAEH,MAAM,OAAO,aAAa;IACP,YAAY,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAC;IAC1C,UAAU,GAAG,MAAM,CAAC,uBAAuB,CAAC,CAAC;IAEtD,GAAG,GAAiB,IAAI,CAAC;IACzB,aAAa,GAAG,IAAI,GAAG,EAA2B,CAAC;IACnD,YAAY,GAAgB,EAAE,CAAC;IAC/B,cAAc,GAA0B,IAAI,CAAC;IAC7C,aAAa,GAAwB,IAAI,CAAC;IAC1C,eAAe,GAAG,wBAAwB,CAAC;IAC3C,cAAc,GACpB,IAAI,CAAC;IACC,eAAe,GAA2C,IAAI,CAAC;IAEvE,MAAM;QACJ,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IAED,aAAa;QACX,OAAO,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC;IAC1B,CAAC;IAED,IAAI,CAAC,OAA4B;QAC/B,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,IAAI,CAAC,uEAAuE,CAAC,CAAC;YACtF,OAAO,IAAI,CAAC,GAAG,CAAC;QAClB,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;QACrD,CAAC;QACD,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,qBAAqB,EAAE,CAAC;QACjE,IAAI,KAAK,KAAK,CAAC,IAAI,MAAM,KAAK,CAAC,EAAE,CAAC;YAChC,OAAO,CAAC,IAAI,CACV,8EAA8E,CAC/E,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QAEzD,MAAM,QAAQ,GAAG,eAAe,CAAC;YAC/B,IAAI,EAAE,OAAO,CAAC,eAAe,KAAK,KAAK;YACvC,MAAM,EAAE,KAAK;YACb,WAAW,EAAE,KAAK;SACnB,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,SAAS,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC;QAEhD,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC;YAC9B,MAAM,SAAS,GAAG,OAAO,CAAC,uBAAuB,IAAI,WAAW,CAAC;YACjE,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC;YAC5C,QAAQ,CAAC,IAAI,CACX,IAAI,aAAa,CAAC;gBAChB,gBAAgB,EAAE,cAAc,CAAC,SAAS,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACnE,UAAU,EAAE,SAAS;gBACrB,SAAS,EAAE,yBAAyB;gBACpC,WAAW,EAAE,EAAE;aAChB,CAAC,CACH,CAAC;QACJ,CAAC;QAED,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC;YACpB,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,UAAU,EAAE,OAAO,CAAC,cAAc;SACnC,CAAC,CAAC;QAEH,IAAI,CAAC,GAAG,GAAG,IAAI,KAAK,CAAC;YACnB,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,IAAI;YACJ,QAAQ;YACR,MAAM,EAAE,EAAE;SACX,CAAC,CAAC;QAEH,IAAI,OAAO,CAAC,OAAO,IAAI,IAAI,EAAE,CAAC;YAC5B,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,CAAC,sBAAsB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YACjF,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC;YACrC,IAAI,CAAC,eAAe,GAAG,cAAc,CAAC,EAAE,CAAC;QAC3C,CAAC;QACD,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,IAAI,EAAE,EAAE,EAAE,sBAAsB,EAAE,KAAK,EAAE,CAAC,CAAC;QAEzE,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACnC,yCAAyC;QACzC,cAAc,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;QAExC,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IAED;;OAEG;IACH,UAAU,CACR,OAA4B,EAC5B,OAA8C;QAE9C,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YACd,OAAO;QACT,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAClD,IAAI,OAAO,EAAE,sBAAsB,KAAK,KAAK,EAAE,CAAC;YAC9C,kEAAkE;QACpE,CAAC;QAED,yEAAyE;QACzE,KAAK,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YAC/C,MAAM,WAAW,GACf,EAAE,KAAK,wBAAwB;gBAC/B,OAAO,EAAE,sBAAsB,KAAK,KAAK;gBACzC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACnB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;gBACrC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;gBACpC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YAChC,CAAC;QACH,CAAC;QAED,0CAA0C;QAC1C,MAAM,MAAM,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAC9B,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,CAC5C,CAAC;QAEF,KAAK,MAAM,MAAM,IAAI,MAAM,EAAE,CAAC;YAC5B,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YACnD,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;gBACtD,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;gBAC9B,SAAS;YACX,CAAC;YAED,IAAI,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;gBAC7D,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;gBACrC,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;gBACtD,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;YAChC,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;gBACrD,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC;YAC3B,CAAC;QACH,CAAC;QAED,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED,kBAAkB,CAAC,OAAe,EAAE,OAAgB;QAClD,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAChD,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,IAAI,OAAO,CAAC,MAAM,CAAC,OAAO,IAAI,OAAO,EAAE,CAAC;YACtC,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC;YAC/B,IAAI,CAAC,YAAY,CAAC,uBAAuB,CACvC,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,EAChC,IAAI,CAAC,eAAe,CACrB,CAAC;YACF,OAAO;QACT,CAAC;QAED,IAAI,OAAO,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;YACvC,wCAAwC;YACxC,MAAM,YAAY,GAAG,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CACxD,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,IAAI,CAAC,EAAE,KAAK,OAAO,CACrD,CAAC;YACF,IAAI,YAAY,EAAE,CAAC;gBACjB,IAAI,CAAC,eAAe,GAAG,YAAY,CAAC,EAAE,CAAC;gBACvC,IAAI,CAAC,YAAY,CAAC,uBAAuB,CACvC,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,EAChC,IAAI,CAAC,eAAe,CACrB,CAAC;YACJ,CAAC;YACD,OAAO;QACT,CAAC;QAED,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACrD,OAAO,CAAC,MAAM,GAAG,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC;IAClD,CAAC;IAED,eAAe,CAAC,OAAe,EAAE,OAAe;QAC9C,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAChD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO;QACT,CAAC;QACD,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACrD,OAAO,CAAC,MAAM,GAAG,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC;IAClD,CAAC;IAED,gBAAgB;QACd,OAAO,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED,SAAS,CAAC,MAAkB,EAAE,IAAa;QACzC,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC;QACjC,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO;QACT,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QACjC,MAAM,UAAU,GACd,OAAO,IAAI,IAAI;YACf,OAAO,CAAC,MAAM,IAAI,CAAC;YACnB,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;YACvC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;QAC1C,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QACzB,CAAC;QACD,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;YACjB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;IAED,OAAO,CAAC,IAAY;QAClB,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC;QACjC,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO;QACT,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC/B,IAAI,OAAO,IAAI,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC;YACvD,OAAO;QACT,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACrB,CAAC;IAED,OAAO;QACL,OAAO,IAAI,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,IAAI,SAAS,CAAC;IACpD,CAAC;IAED,MAAM,CAAC,KAAa;QAClB,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC;QACjC,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO;QACT,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC5B,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;YACjB,OAAO;QACT,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CACnB,IAAI,CAAC,UAAU,EAAE,IAAI,wBAAwB,EAC7C,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG,KAAK,CAAC,CAC/C,CAAC;QACF,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC;IAC9C,CAAC;IAED,uEAAuE;IACvE,UAAU,CAAC,OAA2B;QACpC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YACd,OAAO;QACT,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;QAClE,IAAI,QAAQ,EAAE,CAAC;YACb,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACrC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,wBAAwB,CAAC,CAAC;QACtD,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC;QAClE,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;QAC9B,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,EAAE,CAAC;QAClC,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,oCAAoC;QACpC,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC;IACtD,CAAC;IAED,SAAS,CACP,MAAwC,EACxC,OAAqE;QAErE,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC;QACjC,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO;QACT,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE;YACf,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;YAC7C,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,EAAE;YAC/B,QAAQ,EAAE,OAAO,EAAE,QAAQ,IAAI,GAAG;SACnC,CAAC,CAAC;IACL,CAAC;IAED,uFAAuF;IACvF,eAAe,CACb,UAA4C,EAC5C,OAAqE;QAErE,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC;QACrB,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,OAAO;QACT,CAAC;QACD,MAAM,QAAQ,GAAG,GAAG,CAAC,OAAO,EAAE,CAAC,aAAa,EAAE,CAAC,OAAO,EAAE,CAAC;QACzD,MAAM,MAAM,GAAG,eAAe,CAAC,UAAU,EAAE,WAAW,EAAE,QAAQ,CAK/D,CAAC;QACF,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,CAAC;IAED;;;OAGG;IACH,WAAW,CACT,aAAwD,oCAAoC,EAC5F,OAAqE;QAErE,IAAI,CAAC,eAAe,CAAC,CAAC,GAAG,UAAU,CAAqC,EAAE;YACxE,OAAO,EAAE,EAAE;YACX,QAAQ,EAAE,GAAG;YACb,OAAO,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;YACzB,GAAG,OAAO;SACX,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,uBAAuB,CACrB,IAAY,EACZ,OAAgC;QAEhC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC;QACrB,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,OAAO;QACT,CAAC;QACD,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,MAAM,QAAQ,GAAG,GAAG,CAAC,OAAO,EAAE,CAAC,aAAa,EAAE,CAAC,OAAO,EAAE,CAAC;QACzD,MAAM,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;QAC7B,IAAI,QAAQ,GAAwB,EAAE,CAAC;QACvC,IAAI,CAAC;YACH,QAAQ,GAAG,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE;gBACnC,cAAc,EAAE,OAAO,EAAE,cAAc,IAAI,WAAW;gBACtD,iBAAiB,EAAE,QAAQ;aAC5B,CAAwB,CAAC;QAC5B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,KAAK,CAAC,2CAA2C,EAAE,GAAG,CAAC,CAAC;YAChE,OAAO;QACT,CAAC;QACD,IAAI,CAAC,oBAAoB,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC/C,CAAC;IAED,oBAAoB,CAClB,QAA6B,EAC7B,OAAgC;QAEhC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YACd,OAAO;QACT,CAAC;QACD,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,CAAC,eAAe,EAAE,KAAK,EAAE,CAAC;QAC9B,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;YACpB,IAAI,CAAC,eAAe,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;QAC9C,CAAC;QACD,MAAM,SAAS,GAAG,OAAO,EAAE,GAAG,KAAK,KAAK,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;QAChE,IAAI,SAAS,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACtC,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,CAAC;YAChD,IACE,MAAM;gBACN,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;gBAC1B,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;gBAC1B,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;gBAC1B,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAC1B,CAAC;gBACD,IAAI,CAAC,SAAS,CAAC,MAA0C,EAAE;oBACzD,OAAO,EAAE,EAAE;oBACX,QAAQ,EAAE,GAAG;oBACb,GAAG,OAAO,EAAE,UAAU;iBACvB,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IAED,cAAc;QACZ,IAAI,CAAC,eAAe,EAAE,KAAK,EAAE,CAAC;IAChC,CAAC;IAED,UAAU;QACR,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,CAAC;IACzB,CAAC;IAED,OAAO,CAAC,OAA0C;QAChD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC;QACrB,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,OAAO,GAAG,EAAE,CAAC,SAAS,CAAC;QACzB,CAAC;QAED,MAAM,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,aAAa,EAAE,CAAC,GAAG,EAAE,EAAE;YACxC,MAAM,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC;YAClC,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,mBAAmB,CAChD,UAAU,EACV,GAAG,CAAC,OAAO,EAAE,CAAC,aAAa,EAAE,CAAC,OAAO,EAAE,EACvC,WAAW,CACZ,CAAC;YACF,OAAO,CAAC;gBACN,UAAU,EAAE,CAAC,GAAG,UAAU,CAAC;gBAC3B,MAAM;gBACN,KAAK,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACnC,aAAa,EAAE,GAAG,CAAC,aAAwB;aAC5C,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC5B,OAAO,GAAG,EAAE;YACV,OAAO,CAAC,GAAG,CAAC,CAAC;YACb,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC;QACjE,CAAC,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,YAAY,CAAC,OAA+C;QAC1D,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC;QACrB,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,OAAO,GAAG,EAAE,CAAC,SAAS,CAAC;QACzB,CAAC;QAED,MAAM,IAAI,GAAG,GAAG,CAAC,OAAO,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,GAAS,EAAE;YACtB,OAAO,CAAC;gBACN,MAAM,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBACzC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC;gBACzB,UAAU,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC;gBACrC,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE;aAC7B,CAAC,CAAC;QACL,CAAC,CAAC;QACF,MAAM,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QACpC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC5B,OAAO,GAAG,EAAE;YACV,OAAO,CAAC,GAAG,CAAC,CAAC;YACb,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC;QACjE,CAAC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,OAAO;QACL,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC3B,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;QAEvB,IAAI,CAAC,aAAa,EAAE,EAAE,CAAC;QACvB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC1B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAE3B,IAAI,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;YACpC,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAC5C,CAAC;QACD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAE5B,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;YAC9B,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;YACnB,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC;QAClB,CAAC;QACD,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;IAC7B,CAAC;IAEO,oBAAoB;QAC1B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC;QACrB,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,OAAO;QACT,CAAC;QACD,IAAI,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YAChD,OAAO;QACT,CAAC;QACD,IAAI,CAAC,eAAe,GAAG,IAAI,YAAY,EAAE,CAAC;QAC1C,IAAI,CAAC,cAAc,GAAG,IAAI,WAAW,CAAC;YACpC,MAAM,EAAE,IAAI,CAAC,eAAe;YAC5B,UAAU,EAAE,EAAE,UAAU,EAAE,0BAA0B,EAAE;YACtD,KAAK,EAAE,IAAI,CAAC,oBAAoB,EAAE;YAClC,MAAM,EAAE,GAAG;YACX,oBAAoB,EAAE,IAAI;YAC1B,sBAAsB,EAAE,IAAI;SAC7B,CAAC,CAAC;QACH,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACpC,CAAC;IAEO,oBAAoB;QAC1B,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,6BAA6B,EAAE,SAAS,CAAC,CAAC;QACvE,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,6BAA6B,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;QAC3E,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,2BAA2B,EAAE,SAAS,CAAC,CAAC;QAClE,MAAM,OAAO,GAAG,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC;QAE/C,MAAM,SAAS,GAAG,IAAI,KAAK,CAAC;YAC1B,IAAI,EAAE,IAAI,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;YAC/B,MAAM,EAAE,IAAI,MAAM,CAAC;gBACjB,KAAK,EAAE,MAAM;gBACb,KAAK,EAAE,CAAC;aACT,CAAC;SACH,CAAC,CAAC;QAEH,MAAM,UAAU,GAAG,IAAI,KAAK,CAAC;YAC3B,KAAK,EAAE,IAAI,IAAI,CAAC;gBACd,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;gBAChB,YAAY,EAAE,UAAU;gBACxB,YAAY,EAAE,UAAU;gBACxB,GAAG,EAAE,OAAO;gBACZ,KAAK,EAAE,CAAC;aACT,CAAC;SACH,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,EAAE,EAAE;YACjB,MAAM,IAAI,GAAG,OAAO,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE,CAAC;YAC9C,IAAI,IAAI,KAAK,OAAO,IAAI,IAAI,KAAK,YAAY,EAAE,CAAC;gBAC9C,OAAO,UAAU,CAAC;YACpB,CAAC;YACD,OAAO,SAAS,CAAC;QACnB,CAAC,CAAC;IACJ,CAAC;IAED,wDAAwD;IAChD,oBAAoB,CAAC,KAAa;QACxC,MAAM,GAAG,GAAG;;sBAEM,KAAK;;;;KAItB,CAAC,IAAI,EAAE,CAAC;QACT,OAAO,oCAAoC,kBAAkB,CAAC,GAAG,CAAC,EAAE,CAAC;IACvE,CAAC;IAED,2DAA2D;IACnD,QAAQ,CAAC,KAAa,EAAE,QAAgB,EAAE,KAAc;QAC9D,IAAI,OAAO,QAAQ,KAAK,WAAW,EAAE,CAAC;YACpC,OAAO,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QACpE,CAAC;QACD,MAAM,GAAG,GAAG,gBAAgB,CAAC,QAAQ,CAAC,eAAe,CAAC;aACnD,gBAAgB,CAAC,KAAK,CAAC;aACvB,IAAI,EAAE,CAAC;QACV,MAAM,KAAK,GAAG,GAAG,IAAI,QAAQ,CAAC;QAC9B,OAAO,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC9D,CAAC;IAEO,SAAS,CAAC,KAAa,EAAE,KAAa;QAC5C,IAAI,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3D,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YAC7B,OAAO,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,KAAK,GAAG,CAAC,CAAC;QACpE,CAAC;QACD,IAAI,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YAC1B,MAAM,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAC3B,MAAM,IAAI,GACR,GAAG,CAAC,MAAM,KAAK,CAAC;gBACd,CAAC,CAAC,GAAG;qBACA,KAAK,CAAC,EAAE,CAAC;qBACT,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;qBACjB,IAAI,CAAC,EAAE,CAAC;gBACb,CAAC,CAAC,GAAG,CAAC;YACV,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACtB,OAAO,KAAK,CAAC;YACf,CAAC;YACD,MAAM,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACzC,MAAM,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACzC,MAAM,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACzC,OAAO,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,KAAK,GAAG,CAAC;QAC5C,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAEO,eAAe,CAAC,OAAwB;QAC9C,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YACd,OAAO;QACT,CAAC;QACD,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QAC5C,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC;IAEO,oBAAoB;QAC1B,MAAM,QAAQ,GAAG,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACxF,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QACD,MAAM,MAAM,GACV,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,IAAI,CAAC,eAAe,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC;YAC1F,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,IAAI,CAAC;YACpD,QAAQ,CAAC,CAAC,CAAC,CAAC;QACd,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,EAAE,CAAC;QACjC,IAAI,CAAC,YAAY,CAAC,uBAAuB,CAAC,QAAQ,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;IAC5E,CAAC;IAEO,aAAa,CAAC,MAAmB;QACvC,IAAI,OAAO,cAAc,KAAK,WAAW,EAAE,CAAC;YAC1C,OAAO;QACT,CAAC;QACD,IAAI,SAAS,GAAG,CAAC,CAAC,CAAC;QACnB,IAAI,UAAU,GAAG,CAAC,CAAC,CAAC;QACpB,IAAI,KAAK,GAAkB,IAAI,CAAC;QAEhC,IAAI,CAAC,cAAc,GAAG,IAAI,cAAc,CAAC,CAAC,OAAO,EAAE,EAAE;YACnD,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC;YACrC,IAAI,CAAC,IAAI,EAAE,CAAC;gBACV,OAAO;YACT,CAAC;YACD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACrC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACvC,IAAI,KAAK,KAAK,CAAC,IAAI,MAAM,KAAK,CAAC,EAAE,CAAC;gBAChC,OAAO;YACT,CAAC;YACD,IAAI,KAAK,KAAK,SAAS,IAAI,MAAM,KAAK,UAAU,EAAE,CAAC;gBACjD,OAAO;YACT,CAAC;YACD,SAAS,GAAG,KAAK,CAAC;YAClB,UAAU,GAAG,MAAM,CAAC;YACpB,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;gBAClB,oBAAoB,CAAC,KAAK,CAAC,CAAC;YAC9B,CAAC;YACD,KAAK,GAAG,qBAAqB,CAAC,GAAG,EAAE;gBACjC,KAAK,GAAG,IAAI,CAAC;gBACb,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAEpC,IAAI,CAAC,aAAa,GAAG,GAAG,EAAE;YACxB,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;gBAClB,oBAAoB,CAAC,KAAK,CAAC,CAAC;gBAC5B,KAAK,GAAG,IAAI,CAAC;YACf,CAAC;YACD,IAAI,CAAC,cAAc,EAAE,UAAU,EAAE,CAAC;YAClC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC7B,CAAC,CAAC;IACJ,CAAC;wGA3mBU,aAAa;4GAAb,aAAa;;4FAAb,aAAa;kBADzB,UAAU","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport OlMap from 'ol/Map';\nimport View from 'ol/View';\nimport type { Coordinate } from 'ol/coordinate';\nimport { defaults as defaultControls } from 'ol/control/defaults';\nimport ScaleLine from 'ol/control/ScaleLine';\nimport MousePosition from 'ol/control/MousePosition';\nimport { createStringXY } from 'ol/coordinate';\nimport { unByKey } from 'ol/Observable';\nimport type { EventsKey } from 'ol/events';\nimport type Feature from 'ol/Feature';\nimport type Geometry from 'ol/geom/Geometry';\nimport GeoJSON from 'ol/format/GeoJSON';\nimport VectorLayer from 'ol/layer/Vector';\nimport VectorSource from 'ol/source/Vector';\nimport { transformExtent } from 'ol/proj';\nimport { Fill, Icon, Stroke, Style } from 'ol/style';\nimport type { StyleLike } from 'ol/style/Style';\nimport {\n  GEO_MAP_BASEMAP_LAYER_ID,\n  GEO_MAP_DEFAULT_MAX_ZOOM,\n  GEO_MAP_DEFAULT_PROVINCE_EXTENT_4326,\n  GEO_MAP_HIGHLIGHT_LAYER_ID,\n} from '../geo-map.constants';\nimport type {\n  GeoMapBasemapInput,\n  GeoMapClickEvent,\n  GeoMapHighlightOptions,\n  GeoMapLayerConfig,\n  GeoMapViewChangeEvent,\n  MapInitOptions,\n} from '../geo-map.types';\nimport {\n  CreatedMapLayer,\n  GeoMapLayerService,\n} from './geo-map-layer.service';\nimport { GeoMapProjectionService } from './geo-map-projection.service';\n\nexport interface GeoMapCreateOptions extends MapInitOptions {\n  basemap?: GeoMapBasemapInput;\n  layers?: GeoMapLayerConfig[];\n  /** Show OL MousePosition control (raw; UI chrome may wrap later). */\n  showMousePosition?: boolean;\n  mousePositionProjection?: string;\n  /** When false, hide built-in OL zoom (use `geo-map-zoom` instead). */\n  showZoomControl?: boolean;\n}\n\n/**\n * Owns a single OpenLayers Map instance for the providing component injector.\n * Do not put Map/Layer objects into Angular template state.\n */\n@Injectable()\nexport class GeoMapService {\n  private readonly layerService = inject(GeoMapLayerService);\n  private readonly projection = inject(GeoMapProjectionService);\n\n  private map: OlMap | null = null;\n  private managedLayers = new Map<string, CreatedMapLayer>();\n  private listenerKeys: EventsKey[] = [];\n  private resizeObserver: ResizeObserver | null = null;\n  private resizeCleanup: (() => void) | null = null;\n  private activeBasemapId = GEO_MAP_BASEMAP_LAYER_ID;\n  private highlightLayer: VectorLayer<VectorSource<Feature<Geometry>>> | null =\n    null;\n  private highlightSource: VectorSource<Feature<Geometry>> | null = null;\n\n  getMap(): OlMap | null {\n    return this.map;\n  }\n\n  isInitialized(): boolean {\n    return this.map != null;\n  }\n\n  init(options: GeoMapCreateOptions): OlMap {\n    if (this.map) {\n      console.warn('[GeoMapService] Map already initialized; returning existing instance.');\n      return this.map;\n    }\n\n    if (!options.target) {\n      throw new Error('Map target element is required.');\n    }\n    const { width, height } = options.target.getBoundingClientRect();\n    if (width === 0 || height === 0) {\n      console.warn(\n        '[GeoMapService] Map container has zero size; call updateSize() after layout.',\n      );\n    }\n\n    this.projection.ensureRegistered(options.viewProjection);\n\n    const controls = defaultControls({\n      zoom: options.showZoomControl !== false,\n      rotate: false,\n      attribution: false,\n    }).extend([new ScaleLine({ units: 'metric' })]);\n\n    if (options.showMousePosition) {\n      const mouseProj = options.mousePositionProjection ?? 'EPSG:4326';\n      this.projection.ensureRegistered(mouseProj);\n      controls.push(\n        new MousePosition({\n          coordinateFormat: createStringXY(mouseProj === 'EPSG:4326' ? 6 : 2),\n          projection: mouseProj,\n          className: 'geo-map__mouse-position',\n          placeholder: '',\n        }),\n      );\n    }\n\n    const view = new View({\n      center: options.center,\n      zoom: options.zoom,\n      minZoom: options.minZoom,\n      maxZoom: options.maxZoom,\n      projection: options.viewProjection,\n    });\n\n    this.map = new OlMap({\n      target: options.target,\n      view,\n      controls,\n      layers: [],\n    });\n\n    if (options.basemap != null) {\n      const basemapCreated = this.layerService.createFromBasemapInput(options.basemap);\n      this.addManagedLayer(basemapCreated);\n      this.activeBasemapId = basemapCreated.id;\n    }\n    this.syncLayers(options.layers ?? [], { replaceBasemapShortcut: false });\n\n    this.observeResize(options.target);\n    // Ensure correct canvas size after paint\n    queueMicrotask(() => this.updateSize());\n\n    return this.map;\n  }\n\n  /**\n   * Sync layer stack with configs. Preserves OL layers when only visibility/opacity change.\n   */\n  syncLayers(\n    configs: GeoMapLayerConfig[],\n    options?: { replaceBasemapShortcut?: boolean },\n  ): void {\n    if (!this.map) {\n      return;\n    }\n\n    const nextIds = new Set(configs.map((c) => c.id));\n    if (options?.replaceBasemapShortcut === false) {\n      // Keep existing basemap shortcut layer unless configs include it.\n    }\n\n    // Remove obsolete (except reserved basemap shortcut when not in configs)\n    for (const [id, managed] of this.managedLayers) {\n      const keepBasemap =\n        id === GEO_MAP_BASEMAP_LAYER_ID &&\n        options?.replaceBasemapShortcut === false &&\n        !nextIds.has(id);\n      if (!nextIds.has(id) && !keepBasemap) {\n        this.map.removeLayer(managed.layer);\n        this.managedLayers.delete(id);\n      }\n    }\n\n    // Sort by zIndex for predictable stacking\n    const sorted = [...configs].sort(\n      (a, b) => (a.zIndex ?? 0) - (b.zIndex ?? 0),\n    );\n\n    for (const config of sorted) {\n      const existing = this.managedLayers.get(config.id);\n      if (!existing) {\n        const created = this.layerService.createLayer(config);\n        this.addManagedLayer(created);\n        continue;\n      }\n\n      if (this.layerService.needsRecreate(existing.config, config)) {\n        this.map.removeLayer(existing.layer);\n        const created = this.layerService.createLayer(config);\n        this.addManagedLayer(created);\n      } else {\n        this.layerService.patchLayer(existing.layer, config);\n        existing.config = config;\n      }\n    }\n\n    this.enforceSingleBasemap();\n  }\n\n  setLayerVisibility(layerId: string, visible: boolean): void {\n    const managed = this.managedLayers.get(layerId);\n    if (!managed || !this.map) {\n      return;\n    }\n\n    if (managed.config.basemap && visible) {\n      this.activeBasemapId = layerId;\n      this.layerService.resolveBasemapExclusive(\n        [...this.managedLayers.values()],\n        this.activeBasemapId,\n      );\n      return;\n    }\n\n    if (managed.config.basemap && !visible) {\n      // Keep at least one basemap if possible\n      const otherBasemap = [...this.managedLayers.values()].find(\n        (item) => item.config.basemap && item.id !== layerId,\n      );\n      if (otherBasemap) {\n        this.activeBasemapId = otherBasemap.id;\n        this.layerService.resolveBasemapExclusive(\n          [...this.managedLayers.values()],\n          this.activeBasemapId,\n        );\n      }\n      return;\n    }\n\n    this.layerService.setVisible(managed.layer, visible);\n    managed.config = { ...managed.config, visible };\n  }\n\n  setLayerOpacity(layerId: string, opacity: number): void {\n    const managed = this.managedLayers.get(layerId);\n    if (!managed) {\n      return;\n    }\n    this.layerService.setOpacity(managed.layer, opacity);\n    managed.config = { ...managed.config, opacity };\n  }\n\n  getManagedLayers(): CreatedMapLayer[] {\n    return [...this.managedLayers.values()];\n  }\n\n  setCenter(center: Coordinate, zoom?: number): void {\n    const view = this.map?.getView();\n    if (!view) {\n      return;\n    }\n    const current = view.getCenter();\n    const sameCenter =\n      current != null &&\n      current.length >= 2 &&\n      Math.abs(current[0] - center[0]) < 1e-6 &&\n      Math.abs(current[1] - center[1]) < 1e-6;\n    if (!sameCenter) {\n      view.setCenter(center);\n    }\n    if (zoom != null) {\n      this.setZoom(zoom);\n    }\n  }\n\n  setZoom(zoom: number): void {\n    const view = this.map?.getView();\n    if (!view) {\n      return;\n    }\n    const current = view.getZoom();\n    if (current != null && Math.abs(current - zoom) < 1e-6) {\n      return;\n    }\n    view.setZoom(zoom);\n  }\n\n  getZoom(): number | undefined {\n    return this.map?.getView().getZoom() ?? undefined;\n  }\n\n  zoomBy(delta: number): void {\n    const view = this.map?.getView();\n    if (!view) {\n      return;\n    }\n    const zoom = view.getZoom();\n    if (zoom == null) {\n      return;\n    }\n    const next = Math.min(\n      view.getMaxZoom() ?? GEO_MAP_DEFAULT_MAX_ZOOM,\n      Math.max(view.getMinZoom() ?? 0, zoom + delta),\n    );\n    view.animate({ zoom: next, duration: 180 });\n  }\n\n  /** Replace the shortcut basemap layer (`GEO_MAP_BASEMAP_LAYER_ID`). */\n  setBasemap(basemap: GeoMapBasemapInput): void {\n    if (!this.map) {\n      return;\n    }\n    const existing = this.managedLayers.get(GEO_MAP_BASEMAP_LAYER_ID);\n    if (existing) {\n      this.map.removeLayer(existing.layer);\n      this.managedLayers.delete(GEO_MAP_BASEMAP_LAYER_ID);\n    }\n    const created = this.layerService.createFromBasemapInput(basemap);\n    this.addManagedLayer(created);\n    this.activeBasemapId = created.id;\n    this.enforceSingleBasemap();\n    // Basemap should sit under overlays\n    created.layer.setZIndex(created.config.zIndex ?? 0);\n  }\n\n  fitExtent(\n    extent: [number, number, number, number],\n    options?: { padding?: number[]; maxZoom?: number; duration?: number },\n  ): void {\n    const view = this.map?.getView();\n    if (!view) {\n      return;\n    }\n    view.fit(extent, {\n      padding: options?.padding ?? [48, 48, 48, 48],\n      maxZoom: options?.maxZoom ?? 14,\n      duration: options?.duration ?? 250,\n    });\n  }\n\n  /** Fit lon/lat extent (EPSG:4326) after transforming to the active view projection. */\n  fitLonLatExtent(\n    extent4326: [number, number, number, number],\n    options?: { padding?: number[]; maxZoom?: number; duration?: number },\n  ): void {\n    const map = this.map;\n    if (!map) {\n      return;\n    }\n    const viewProj = map.getView().getProjection().getCode();\n    const extent = transformExtent(extent4326, 'EPSG:4326', viewProj) as [\n      number,\n      number,\n      number,\n      number,\n    ];\n    this.fitExtent(extent, options);\n  }\n\n  /**\n   * Fit the default (or provided) province extent — TCQH.14 “xem toàn tỉnh”.\n   * Distinct from browser fullscreen (TCQH.15).\n   */\n  fitProvince(\n    extent4326: readonly [number, number, number, number] = GEO_MAP_DEFAULT_PROVINCE_EXTENT_4326,\n    options?: { padding?: number[]; maxZoom?: number; duration?: number },\n  ): void {\n    this.fitLonLatExtent([...extent4326] as [number, number, number, number], {\n      maxZoom: 11,\n      duration: 400,\n      padding: [56, 56, 56, 56],\n      ...options,\n    });\n  }\n\n  /**\n   * Highlight search / select results (TCQH.7–12). Pass GeoJSON Feature or FeatureCollection.\n   */\n  setHighlightFromGeoJson(\n    data: object,\n    options?: GeoMapHighlightOptions,\n  ): void {\n    const map = this.map;\n    if (!map) {\n      return;\n    }\n    this.ensureHighlightLayer();\n    const viewProj = map.getView().getProjection().getCode();\n    const format = new GeoJSON();\n    let features: Feature<Geometry>[] = [];\n    try {\n      features = format.readFeatures(data, {\n        dataProjection: options?.dataProjection ?? 'EPSG:4326',\n        featureProjection: viewProj,\n      }) as Feature<Geometry>[];\n    } catch (err) {\n      console.error('[GeoMapService] Invalid highlight GeoJSON', err);\n      return;\n    }\n    this.setHighlightFeatures(features, options);\n  }\n\n  setHighlightFeatures(\n    features: Feature<Geometry>[],\n    options?: GeoMapHighlightOptions,\n  ): void {\n    if (!this.map) {\n      return;\n    }\n    this.ensureHighlightLayer();\n    this.highlightSource?.clear();\n    if (features.length) {\n      this.highlightSource?.addFeatures(features);\n    }\n    const shouldFit = options?.fit !== false && features.length > 0;\n    if (shouldFit && this.highlightSource) {\n      const extent = this.highlightSource.getExtent();\n      if (\n        extent &&\n        Number.isFinite(extent[0]) &&\n        Number.isFinite(extent[1]) &&\n        Number.isFinite(extent[2]) &&\n        Number.isFinite(extent[3])\n      ) {\n        this.fitExtent(extent as [number, number, number, number], {\n          maxZoom: 17,\n          duration: 280,\n          ...options?.fitOptions,\n        });\n      }\n    }\n  }\n\n  clearHighlight(): void {\n    this.highlightSource?.clear();\n  }\n\n  updateSize(): void {\n    this.map?.updateSize();\n  }\n\n  onClick(handler: (event: GeoMapClickEvent) => void): () => void {\n    const map = this.map;\n    if (!map) {\n      return () => undefined;\n    }\n\n    const key = map.on('singleclick', (evt) => {\n      const coordinate = evt.coordinate;\n      const lonLat = this.projection.transformCoordinate(\n        coordinate,\n        map.getView().getProjection().getCode(),\n        'EPSG:4326',\n      );\n      handler({\n        coordinate: [...coordinate],\n        lonLat,\n        pixel: [evt.pixel[0], evt.pixel[1]],\n        originalEvent: evt.originalEvent as UIEvent,\n      });\n    });\n    this.listenerKeys.push(key);\n    return () => {\n      unByKey(key);\n      this.listenerKeys = this.listenerKeys.filter((k) => k !== key);\n    };\n  }\n\n  /**\n   * Emit after the view settles (`moveend`), not on every resolution tick —\n   * continuous emitters flood Storybook Actions / host bindings and cause UI flicker.\n   */\n  onViewChange(handler: (event: GeoMapViewChangeEvent) => void): () => void {\n    const map = this.map;\n    if (!map) {\n      return () => undefined;\n    }\n\n    const view = map.getView();\n    const emit = (): void => {\n      handler({\n        center: [...(view.getCenter() ?? [0, 0])],\n        zoom: view.getZoom() ?? 0,\n        resolution: view.getResolution() ?? 0,\n        rotation: view.getRotation(),\n      });\n    };\n    const key = map.on('moveend', emit);\n    this.listenerKeys.push(key);\n    return () => {\n      unByKey(key);\n      this.listenerKeys = this.listenerKeys.filter((k) => k !== key);\n    };\n  }\n\n  /**\n   * Tear down map, listeners, and resize observer. Safe to call multiple times.\n   */\n  destroy(): void {\n    unByKey(this.listenerKeys);\n    this.listenerKeys = [];\n\n    this.resizeCleanup?.();\n    this.resizeCleanup = null;\n    this.resizeObserver = null;\n\n    if (this.highlightLayer && this.map) {\n      this.map.removeLayer(this.highlightLayer);\n    }\n    this.highlightLayer = null;\n    this.highlightSource = null;\n\n    if (this.map) {\n      this.map.setTarget(undefined);\n      this.map.dispose();\n      this.map = null;\n    }\n    this.managedLayers.clear();\n  }\n\n  private ensureHighlightLayer(): void {\n    const map = this.map;\n    if (!map) {\n      return;\n    }\n    if (this.highlightLayer && this.highlightSource) {\n      return;\n    }\n    this.highlightSource = new VectorSource();\n    this.highlightLayer = new VectorLayer({\n      source: this.highlightSource,\n      properties: { geoLayerId: GEO_MAP_HIGHLIGHT_LAYER_ID },\n      style: this.createHighlightStyle(),\n      zIndex: 450,\n      updateWhileAnimating: true,\n      updateWhileInteracting: true,\n    });\n    map.addLayer(this.highlightLayer);\n  }\n\n  private createHighlightStyle(): StyleLike {\n    const stroke = this.cssColor('--geo-color-warning-default', '#f59e0b');\n    const fill = this.cssColor('--geo-color-warning-default', '#f59e0b', 0.22);\n    const pin = this.cssColor('--geo-color-error-default', '#dc2626');\n    const pinIcon = this.createPinIconDataUri(pin);\n\n    const areaStyle = new Style({\n      fill: new Fill({ color: fill }),\n      stroke: new Stroke({\n        color: stroke,\n        width: 3,\n      }),\n    });\n\n    const pointStyle = new Style({\n      image: new Icon({\n        anchor: [0.5, 1],\n        anchorXUnits: 'fraction',\n        anchorYUnits: 'fraction',\n        src: pinIcon,\n        scale: 1,\n      }),\n    });\n\n    return (feature) => {\n      const type = feature.getGeometry()?.getType();\n      if (type === 'Point' || type === 'MultiPoint') {\n        return pointStyle;\n      }\n      return areaStyle;\n    };\n  }\n\n  /** Inline SVG map pin for clicked / selected points. */\n  private createPinIconDataUri(color: string): string {\n    const svg = `\n      <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"32\" height=\"40\" viewBox=\"0 0 32 40\">\n        <path fill=\"${color}\" stroke=\"#ffffff\" stroke-width=\"1.75\"\n          d=\"M16 1C9.373 1 4 6.373 4 13c0 8.284 12 26 12 26s12-17.716 12-26C28 6.373 22.627 1 16 1z\"/>\n        <circle cx=\"16\" cy=\"13\" r=\"4.5\" fill=\"#ffffff\"/>\n      </svg>\n    `.trim();\n    return `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;\n  }\n\n  /** Resolve a design token for OpenLayers canvas styles. */\n  private cssColor(token: string, fallback: string, alpha?: number): string {\n    if (typeof document === 'undefined') {\n      return alpha == null ? fallback : this.withAlpha(fallback, alpha);\n    }\n    const raw = getComputedStyle(document.documentElement)\n      .getPropertyValue(token)\n      .trim();\n    const color = raw || fallback;\n    return alpha == null ? color : this.withAlpha(color, alpha);\n  }\n\n  private withAlpha(color: string, alpha: number): string {\n    if (color.startsWith('rgba(') || color.startsWith('hsla(')) {\n      return color;\n    }\n    if (color.startsWith('rgb(')) {\n      return color.replace('rgb(', 'rgba(').replace(')', `, ${alpha})`);\n    }\n    if (color.startsWith('#')) {\n      const hex = color.slice(1);\n      const full =\n        hex.length === 3\n          ? hex\n              .split('')\n              .map((c) => c + c)\n              .join('')\n          : hex;\n      if (full.length !== 6) {\n        return color;\n      }\n      const r = parseInt(full.slice(0, 2), 16);\n      const g = parseInt(full.slice(2, 4), 16);\n      const b = parseInt(full.slice(4, 6), 16);\n      return `rgba(${r}, ${g}, ${b}, ${alpha})`;\n    }\n    return color;\n  }\n\n  private addManagedLayer(created: CreatedMapLayer): void {\n    if (!this.map) {\n      return;\n    }\n    this.managedLayers.set(created.id, created);\n    this.map.addLayer(created.layer);\n  }\n\n  private enforceSingleBasemap(): void {\n    const basemaps = [...this.managedLayers.values()].filter((item) => item.config.basemap);\n    if (basemaps.length === 0) {\n      return;\n    }\n    const active =\n      basemaps.find((item) => item.id === this.activeBasemapId && (item.config.visible ?? true)) ??\n      basemaps.find((item) => item.config.visible ?? true) ??\n      basemaps[0];\n    this.activeBasemapId = active.id;\n    this.layerService.resolveBasemapExclusive(basemaps, this.activeBasemapId);\n  }\n\n  private observeResize(target: HTMLElement): void {\n    if (typeof ResizeObserver === 'undefined') {\n      return;\n    }\n    let lastWidth = -1;\n    let lastHeight = -1;\n    let rafId: number | null = null;\n\n    this.resizeObserver = new ResizeObserver((entries) => {\n      const rect = entries[0]?.contentRect;\n      if (!rect) {\n        return;\n      }\n      const width = Math.round(rect.width);\n      const height = Math.round(rect.height);\n      if (width === 0 || height === 0) {\n        return;\n      }\n      if (width === lastWidth && height === lastHeight) {\n        return;\n      }\n      lastWidth = width;\n      lastHeight = height;\n      if (rafId != null) {\n        cancelAnimationFrame(rafId);\n      }\n      rafId = requestAnimationFrame(() => {\n        rafId = null;\n        this.updateSize();\n      });\n    });\n    this.resizeObserver.observe(target);\n\n    this.resizeCleanup = () => {\n      if (rafId != null) {\n        cancelAnimationFrame(rafId);\n        rafId = null;\n      }\n      this.resizeObserver?.disconnect();\n      this.resizeObserver = null;\n    };\n  }\n}\n"]}