@geoit/ui 0.0.2 → 0.0.5

package/esm2022/lib/figma/geo-map/geo-map.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geo-map.types.js","sourceRoot":"","sources":["../../../../../../projects/geo-ui/src/lib/figma/geo-map/geo-map.types.ts"],"names":[],"mappings":"","sourcesContent":["import type Feature from 'ol/Feature';\nimport type Geometry from 'ol/geom/Geometry';\n\n/** Supported map layer source kinds. */\nexport type GeoMapLayerType =\n  | 'osm'\n  | 'xyz'\n  | 'wms'\n  | 'wmts'\n  | 'vector'\n  | 'geojson';\n\n/** Layer load lifecycle for panel / chrome. */\nexport type GeoMapLayerStatus = 'idle' | 'loading' | 'ready' | 'error';\n\nexport interface ProjectionConfig {\n  code: string;\n  /** Full proj4 definition string. Must be supplied by env/API — never invent VN-2000 params. */\n  definition: string;\n  extent?: [number, number, number, number];\n  units?: string;\n}\n\nexport interface GeoMapLayerBase {\n  id: string;\n  title: string;\n  visible?: boolean;\n  /** 0–1 */\n  opacity?: number;\n  zIndex?: number;\n  minZoom?: number;\n  maxZoom?: number;\n  /** Treat as basemap (only one active at a time). */\n  basemap?: boolean;\n  /** Group key for layer panel sections (`base-map`, `qhsdd`, …). */\n  group?: string;\n  /** Display title for the group accordion (falls back to group key). */\n  groupLabel?: string;\n  /** Selection UX within the group: radio (`single`) or checkbox (`multi`). */\n  groupSelection?: 'single' | 'multi';\n  /** Eligible for identify / GetFeatureInfo. */\n  queryable?: boolean;\n  legendUrl?: string;\n  projection?: string;\n  metadata?: Record<string, unknown>;\n}\n\nexport interface GeoMapOsmLayerConfig extends GeoMapLayerBase {\n  type: 'osm';\n}\n\nexport interface GeoMapXyzLayerConfig extends GeoMapLayerBase {\n  type: 'xyz';\n  url: string;\n  attributions?: string | string[];\n  maxZoom?: number;\n  crossOrigin?: string | null;\n}\n\nexport interface GeoMapWmsLayerConfig extends GeoMapLayerBase {\n  type: 'wms';\n  url: string;\n  params: Record<string, string | number | boolean>;\n  serverType?: 'geoserver' | 'mapserver' | 'qgis' | 'carmentaserver';\n  crossOrigin?: string | null;\n  /** Optional WMS layer name when not only in `params.LAYERS`. */\n  layerName?: string;\n}\n\nexport interface GeoMapWmtsLayerConfig extends GeoMapLayerBase {\n  type: 'wmts';\n  url: string;\n  layer: string;\n  matrixSet: string;\n  format?: string;\n  style?: string;\n  projection?: string;\n  crossOrigin?: string | null;\n}\n\nexport interface GeoMapGeoJsonLayerConfig extends GeoMapLayerBase {\n  type: 'geojson';\n  /** Inline GeoJSON object or URL string. */\n  data: object | string;\n  dataProjection?: string;\n  featureProjection?: string;\n}\n\nexport interface GeoMapVectorLayerConfig extends GeoMapLayerBase {\n  type: 'vector';\n  /** Pre-built OL features (app-owned). */\n  features?: Feature<Geometry>[];\n}\n\nexport type GeoMapLayerConfig =\n  | GeoMapOsmLayerConfig\n  | GeoMapXyzLayerConfig\n  | GeoMapWmsLayerConfig\n  | GeoMapWmtsLayerConfig\n  | GeoMapGeoJsonLayerConfig\n  | GeoMapVectorLayerConfig;\n\nexport type GeoMapBasemapInput =\n  | 'osm'\n  | {\n      type: 'xyz';\n      url: string;\n      attributions?: string | string[];\n      maxZoom?: number;\n      title?: string;\n    };\n\n/** Alias used by basemap switcher output. */\nexport type GeoMapBasemap = GeoMapBasemapInput;\n\nexport interface GeoMapBasemapOption {\n  id: string;\n  label: string;\n  basemap: GeoMapBasemap;\n  previewUrl?: string;\n}\n\nexport type GeoMapLocateErrorReason =\n  | 'unsupported'\n  | 'denied'\n  | 'unavailable'\n  | 'timeout'\n  | 'unknown';\n\nexport interface GeoMapClickEvent {\n  /** Coordinate in view projection. */\n  coordinate: number[];\n  /** Lon/lat (EPSG:4326) as [longitude, latitude]. */\n  lonLat: [number, number];\n  pixel: [number, number];\n  originalEvent: UIEvent;\n}\n\nexport interface GeoMapViewChangeEvent {\n  center: number[];\n  zoom: number;\n  resolution: number;\n  rotation: number;\n}\n\nexport interface GeoMapLayerVisibilityChange {\n  layerId: string;\n  visible: boolean;\n}\n\nexport interface GeoMapLayerOpacityChange {\n  layerId: string;\n  opacity: number;\n}\n\nexport interface GeoMapLayerRuntimeState {\n  id: string;\n  status: GeoMapLayerStatus;\n  errorMessage?: string;\n}\n\nexport interface GeoMapCoordinate {\n  /** [x, y] or [longitude, latitude] in `projection`. */\n  coordinates: [number, number];\n  projection: string;\n}\n\nexport interface MapInitOptions {\n  target: HTMLElement;\n  center: number[];\n  zoom: number;\n  minZoom: number;\n  maxZoom: number;\n  viewProjection: string;\n}\n\nexport interface GeoMapLegendItem {\n  label: string;\n  /** Optional land-use code (e.g. ONT, SKC). */\n  code?: string;\n  /** CSS color for swatch — prefer design tokens when possible. */\n  color?: string;\n  swatchUrl?: string;\n}\n\nexport type GeoMapMeasureMode = 'none' | 'distance' | 'area';\n\nexport interface GeoMapMeasureResult {\n  mode: Exclude<GeoMapMeasureMode, 'none'>;\n  /** Raw value in meters (distance) or m² (area). */\n  value: number;\n  /** Human-readable label (m/km or m²/ha). */\n  label: string;\n  geometry: Geometry | null;\n}\n\nexport interface GeoMapToolbarAction {\n  id: string;\n  label?: string;\n  /** ng-zorro / geo-icon type (fallback when `iconSrc` is omitted). */\n  icon?: string;\n  /** Exported Figma / static asset URL (prefer over `icon`). */\n  iconSrc?: string;\n  active?: boolean;\n  checked?: boolean;\n  disabled?: boolean;\n  iconOnly?: boolean;\n  tooltip?: string;\n  /** Filled primary control (e.g. Home). */\n  variant?: 'default' | 'primary';\n}\n\n/** Search modes for portal tra cứu (TCQH.7–11). */\nexport type GeoMapSearchMode =\n  | 'owner'\n  | 'certificate'\n  | 'coordinates'\n  | 'address'\n  | 'parcel';\n\nexport interface GeoMapSearchQuery {\n  mode: GeoMapSearchMode;\n  /** Field values keyed by mode-specific input ids. */\n  values: Record<string, string>;\n}\n\nexport interface GeoMapSearchResultItem {\n  id: string;\n  title: string;\n  subtitle?: string;\n  /** Lon/lat center for pan (EPSG:4326). */\n  center4326?: [number, number];\n  /** Lon/lat extent for fit (EPSG:4326). */\n  extent4326?: [number, number, number, number];\n  /** Optional GeoJSON Feature / FeatureCollection for map highlight. */\n  geojson?: object;\n  /** Detail payload for `geo-map-parcel-popup`. */\n  parcel?: GeoMapParcelDetail;\n}\n\n/** Audience controls which parcel fields are shown (TCQH.12). */\nexport type GeoMapParcelAudience = 'citizen' | 'specialist';\n\nexport interface GeoMapParcelDetail {\n  /** Mã thửa đất (hiển thị ở Thông tin chung). */\n  parcelCode?: string;\n  parcelNumber?: string;\n  sheetNumber?: string;\n  ward?: string;\n  province?: string;\n  area?: string;\n  legalArea?: string;\n  landUse?: string;\n  address?: string;\n  useForm?: string;\n  registrationStatus?: string;\n  /** Chuyên viên / mở rộng. */\n  shapeInfo?: string;\n  planningInfo?: string;\n  /** Giá đất — mặc định UI hiện «Đang cập nhật» nếu trống. */\n  landPrice?: string;\n  /** URL ảnh sơ đồ thửa (tuỳ chọn). */\n  diagramUrl?: string;\n  /** Extra rows when host needs more fields. */\n  extraFields?: Array<{ label: string; value: string }>;\n}\n\nexport interface GeoMapHighlightOptions {\n  dataProjection?: string;\n  /** Fit view to highlight extent (default true when features exist). */\n  fit?: boolean;\n  fitOptions?: { padding?: number[]; maxZoom?: number; duration?: number };\n}\n"]}

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

@@ -0,0 +1,368 @@
+import { Injectable, inject } from '@angular/core';
+import GeoJSON from 'ol/format/GeoJSON';
+import TileLayer from 'ol/layer/Tile';
+import VectorLayer from 'ol/layer/Vector';
+import OSM from 'ol/source/OSM';
+import TileWMS from 'ol/source/TileWMS';
+import VectorSource from 'ol/source/Vector';
+import XYZ from 'ol/source/XYZ';
+import WMTS from 'ol/source/WMTS';
+import WMTSTileGrid from 'ol/tilegrid/WMTS';
+import { get as getProjection } from 'ol/proj';
+import { getTopLeft, getWidth } from 'ol/extent';
+import { GEO_MAP_BASEMAP_LAYER_ID } from '../geo-map.constants';
+import { GeoMapProjectionService } from './geo-map-projection.service';
+import * as i0 from "@angular/core";
+const LAYER_ID_KEY = 'geoLayerId';
+const LAYER_BASEMAP_KEY = 'geoBasemap';
+const LAYER_GROUP_KEY = 'geoGroup';
+const LAYER_QUERYABLE_KEY = 'geoQueryable';
+/**
+ * Builds and incrementally patches OpenLayers layers from typed configs.
+ * Visibility / opacity updates must not recreate sources.
+ */
+export class GeoMapLayerService {
+    projection = inject(GeoMapProjectionService);
+    runtime = new Map();
+    getRuntimeState(layerId) {
+        return this.runtime.get(layerId);
+    }
+    getAllRuntimeStates() {
+        return [...this.runtime.values()];
+    }
+    createFromBasemapInput(basemap) {
+        if (basemap === 'osm') {
+            const config = {
+                id: GEO_MAP_BASEMAP_LAYER_ID,
+                title: 'OpenStreetMap',
+                type: 'osm',
+                visible: true,
+                opacity: 1,
+                zIndex: 0,
+                basemap: true,
+                group: 'base-map',
+            };
+            return this.createLayer(config);
+        }
+        const config = {
+            id: GEO_MAP_BASEMAP_LAYER_ID,
+            title: basemap.title ?? 'XYZ basemap',
+            type: 'xyz',
+            url: basemap.url,
+            attributions: basemap.attributions,
+            maxZoom: basemap.maxZoom,
+            visible: true,
+            opacity: 1,
+            zIndex: 0,
+            basemap: true,
+            group: 'base-map',
+        };
+        return this.createLayer(config);
+    }
+    createLayer(config) {
+        this.runtime.set(config.id, { id: config.id, status: 'loading' });
+        let layer;
+        try {
+            this.validateConfig(config);
+            switch (config.type) {
+                case 'osm':
+                    layer = this.createOsmLayer(config);
+                    break;
+                case 'xyz':
+                    layer = this.createXyzLayer(config);
+                    break;
+                case 'wms':
+                    layer = this.createWmsLayer(config);
+                    break;
+                case 'wmts':
+                    layer = this.createWmtsLayer(config);
+                    break;
+                case 'geojson':
+                    layer = this.createGeoJsonLayer(config);
+                    break;
+                case 'vector':
+                    layer = this.createVectorLayer(config);
+                    break;
+                default: {
+                    const _exhaustive = config;
+                    throw new Error(`Unsupported layer type: ${JSON.stringify(_exhaustive)}`);
+                }
+            }
+            this.applyCommonOptions(layer, config);
+            this.wireSourceStatus(config.id, layer);
+            this.runtime.set(config.id, { id: config.id, status: 'ready' });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`[GeoMapLayerService] Failed to create layer "${config.id}"`, err);
+            this.runtime.set(config.id, {
+                id: config.id,
+                status: 'error',
+                errorMessage: message,
+            });
+            // Placeholder invisible layer so callers can still track id
+            layer = new VectorLayer({
+                source: new VectorSource(),
+                visible: false,
+            });
+            this.applyCommonOptions(layer, { ...config, visible: false });
+        }
+        return { id: config.id, config, layer };
+    }
+    /**
+     * Apply visibility/opacity/zIndex without recreating the OL layer.
+     * Returns true when structural fields changed and the layer should be recreated.
+     */
+    needsRecreate(previous, next) {
+        if (previous.type !== next.type || previous.id !== next.id) {
+            return true;
+        }
+        switch (next.type) {
+            case 'osm':
+                return false;
+            case 'xyz':
+                return (previous.url !== next.url ||
+                    previous.maxZoom !== next.maxZoom);
+            case 'wms':
+                return (previous.url !== next.url ||
+                    JSON.stringify(previous.params) !==
+                        JSON.stringify(next.params) ||
+                    previous.layerName !== next.layerName);
+            case 'wmts':
+                return (previous.url !== next.url ||
+                    previous.layer !== next.layer ||
+                    previous.matrixSet !== next.matrixSet);
+            case 'geojson':
+                return (JSON.stringify(previous.data) !==
+                    JSON.stringify(next.data) ||
+                    previous.dataProjection !== next.dataProjection);
+            case 'vector':
+                return previous.features !== next.features;
+            default:
+                return true;
+        }
+    }
+    patchLayer(layer, config) {
+        layer.setVisible(config.visible ?? true);
+        layer.setOpacity(config.opacity ?? 1);
+        if (config.zIndex != null) {
+            layer.setZIndex(config.zIndex);
+        }
+        if (config.minZoom != null) {
+            layer.setMinZoom(config.minZoom);
+        }
+        if (config.maxZoom != null) {
+            layer.setMaxZoom(config.maxZoom);
+        }
+        layer.set(LAYER_BASEMAP_KEY, !!config.basemap);
+        layer.set(LAYER_GROUP_KEY, config.group ?? '');
+        layer.set(LAYER_QUERYABLE_KEY, !!config.queryable);
+    }
+    setVisible(layer, visible) {
+        layer.setVisible(visible);
+    }
+    setOpacity(layer, opacity) {
+        const clamped = Math.min(1, Math.max(0, opacity));
+        layer.setOpacity(clamped);
+    }
+    getLayerId(layer) {
+        const id = layer.get(LAYER_ID_KEY);
+        return typeof id === 'string' ? id : undefined;
+    }
+    isBasemap(layer) {
+        return !!layer.get(LAYER_BASEMAP_KEY);
+    }
+    resolveBasemapExclusive(layers, activeBasemapId) {
+        for (const item of layers) {
+            if (!item.config.basemap) {
+                continue;
+            }
+            const visible = item.id === activeBasemapId;
+            item.layer.setVisible(visible);
+            item.config = { ...item.config, visible };
+        }
+    }
+    validateConfig(config) {
+        if (!config.id?.trim()) {
+            throw new Error('Layer config requires a non-empty id.');
+        }
+        if (config.type === 'xyz' && !config.url?.trim()) {
+            throw new Error(`XYZ layer "${config.id}" is missing url.`);
+        }
+        if (config.type === 'wms') {
+            if (!config.url?.trim()) {
+                throw new Error(`WMS layer "${config.id}" is missing url.`);
+            }
+            const layersParam = config.layerName ??
+                (config.params['LAYERS'] != null ? String(config.params['LAYERS']) : '');
+            if (!layersParam) {
+                throw new Error(`WMS layer "${config.id}" needs layerName or params.LAYERS.`);
+            }
+        }
+        if (config.type === 'wmts') {
+            if (!config.url?.trim() || !config.layer?.trim() || !config.matrixSet?.trim()) {
+                throw new Error(`WMTS layer "${config.id}" requires url, layer, and matrixSet.`);
+            }
+        }
+        if (config.type === 'geojson' && config.data == null) {
+            throw new Error(`GeoJSON layer "${config.id}" is missing data.`);
+        }
+    }
+    applyCommonOptions(layer, config) {
+        layer.set(LAYER_ID_KEY, config.id);
+        layer.set(LAYER_BASEMAP_KEY, !!config.basemap);
+        layer.set(LAYER_GROUP_KEY, config.group ?? '');
+        layer.set(LAYER_QUERYABLE_KEY, !!config.queryable);
+        layer.setVisible(config.visible ?? true);
+        layer.setOpacity(config.opacity ?? 1);
+        if (config.zIndex != null) {
+            layer.setZIndex(config.zIndex);
+        }
+        if (config.minZoom != null) {
+            layer.setMinZoom(config.minZoom);
+        }
+        if (config.maxZoom != null) {
+            layer.setMaxZoom(config.maxZoom);
+        }
+    }
+    wireSourceStatus(layerId, layer) {
+        if (!(layer instanceof TileLayer)) {
+            return;
+        }
+        const source = layer.getSource();
+        if (!source) {
+            return;
+        }
+        source.on('tileloaderror', () => {
+            console.warn(`[GeoMapLayerService] Tile error on layer "${layerId}"`);
+            this.runtime.set(layerId, {
+                id: layerId,
+                status: 'error',
+                errorMessage: 'Không tải được dữ liệu lớp bản đồ.',
+            });
+        });
+        source.on('tileloadend', () => {
+            const current = this.runtime.get(layerId);
+            if (current?.status === 'error') {
+                return;
+            }
+            this.runtime.set(layerId, { id: layerId, status: 'ready' });
+        });
+    }
+    createOsmLayer(_config) {
+        return new TileLayer({
+            source: new OSM(),
+        });
+    }
+    createXyzLayer(config) {
+        return new TileLayer({
+            source: new XYZ({
+                url: config.url,
+                attributions: config.attributions,
+                maxZoom: config.maxZoom,
+                crossOrigin: config.crossOrigin ?? 'anonymous',
+            }),
+        });
+    }
+    createWmsLayer(config) {
+        const layers = config.layerName ??
+            (config.params['LAYERS'] != null ? String(config.params['LAYERS']) : '');
+        const params = {
+            ...config.params,
+            LAYERS: layers,
+        };
+        return new TileLayer({
+            source: new TileWMS({
+                url: config.url,
+                params,
+                serverType: config.serverType,
+                crossOrigin: config.crossOrigin ?? 'anonymous',
+                projection: config.projection,
+            }),
+        });
+    }
+    createWmtsLayer(config) {
+        const projectionCode = config.projection ?? 'EPSG:3857';
+        this.projection.ensureRegistered(projectionCode);
+        const projection = getProjection(projectionCode);
+        if (!projection) {
+            throw new Error(`WMTS projection "${projectionCode}" is not available.`);
+        }
+        const projectionExtent = projection.getExtent();
+        if (!projectionExtent) {
+            throw new Error(`WMTS projection "${projectionCode}" has no extent; provide a custom tile grid in a later phase.`);
+        }
+        const size = getWidth(projectionExtent) / 256;
+        const resolutions = [];
+        const matrixIds = [];
+        for (let z = 0; z < 20; z += 1) {
+            resolutions[z] = size / Math.pow(2, z);
+            matrixIds[z] = String(z);
+        }
+        return new TileLayer({
+            source: new WMTS({
+                url: config.url,
+                layer: config.layer,
+                matrixSet: config.matrixSet,
+                format: config.format ?? 'image/png',
+                style: config.style ?? '',
+                projection: projectionCode,
+                crossOrigin: config.crossOrigin ?? 'anonymous',
+                tileGrid: new WMTSTileGrid({
+                    origin: getTopLeft(projectionExtent),
+                    resolutions,
+                    matrixIds,
+                }),
+            }),
+        });
+    }
+    createGeoJsonLayer(config) {
+        const format = new GeoJSON();
+        const source = new VectorSource();
+        const featureProjection = config.featureProjection ?? 'EPSG:3857';
+        const dataProjection = config.dataProjection ?? 'EPSG:4326';
+        if (typeof config.data === 'string') {
+            // URL — let VectorSource load asynchronously
+            const urlSource = new VectorSource({
+                url: config.data,
+                format: new GeoJSON({
+                    dataProjection,
+                    featureProjection,
+                }),
+            });
+            urlSource.on('featuresloaderror', () => {
+                console.error(`[GeoMapLayerService] GeoJSON load error "${config.id}"`);
+                this.runtime.set(config.id, {
+                    id: config.id,
+                    status: 'error',
+                    errorMessage: 'Không tải được GeoJSON.',
+                });
+            });
+            return new VectorLayer({ source: urlSource });
+        }
+        try {
+            const features = format.readFeatures(config.data, {
+                dataProjection,
+                featureProjection,
+            });
+            source.addFeatures(features);
+        }
+        catch (err) {
+            console.error(`[GeoMapLayerService] Invalid GeoJSON for "${config.id}"`, err);
+            throw new Error(`GeoJSON không hợp lệ cho lớp "${config.id}".`);
+        }
+        return new VectorLayer({ source });
+    }
+    createVectorLayer(config) {
+        const source = new VectorSource({
+            features: config.features ?? [],
+        });
+        return new VectorLayer({ source });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GeoMapLayerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GeoMapLayerService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GeoMapLayerService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geo-map-layer.service.js","sourceRoot":"","sources":["../../../../../../../projects/geo-ui/src/lib/figma/geo-map/services/geo-map-layer.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport Feature from 'ol/Feature';\nimport GeoJSON from 'ol/format/GeoJSON';\nimport type Geometry from 'ol/geom/Geometry';\nimport type BaseLayer from 'ol/layer/Base';\nimport TileLayer from 'ol/layer/Tile';\nimport VectorLayer from 'ol/layer/Vector';\nimport OSM from 'ol/source/OSM';\nimport TileWMS from 'ol/source/TileWMS';\nimport VectorSource from 'ol/source/Vector';\nimport XYZ from 'ol/source/XYZ';\nimport type { ProjectionLike } from 'ol/proj';\nimport WMTS from 'ol/source/WMTS';\nimport WMTSTileGrid from 'ol/tilegrid/WMTS';\nimport { get as getProjection } from 'ol/proj';\nimport { getTopLeft, getWidth } from 'ol/extent';\nimport { GEO_MAP_BASEMAP_LAYER_ID } from '../geo-map.constants';\nimport type {\n  GeoMapBasemapInput,\n  GeoMapGeoJsonLayerConfig,\n  GeoMapLayerConfig,\n  GeoMapLayerRuntimeState,\n  GeoMapOsmLayerConfig,\n  GeoMapVectorLayerConfig,\n  GeoMapWmsLayerConfig,\n  GeoMapWmtsLayerConfig,\n  GeoMapXyzLayerConfig,\n} from '../geo-map.types';\nimport { GeoMapProjectionService } from './geo-map-projection.service';\n\nconst LAYER_ID_KEY = 'geoLayerId';\nconst LAYER_BASEMAP_KEY = 'geoBasemap';\nconst LAYER_GROUP_KEY = 'geoGroup';\nconst LAYER_QUERYABLE_KEY = 'geoQueryable';\n\nexport interface CreatedMapLayer {\n  id: string;\n  config: GeoMapLayerConfig;\n  layer: BaseLayer;\n}\n\n/**\n * Builds and incrementally patches OpenLayers layers from typed configs.\n * Visibility / opacity updates must not recreate sources.\n */\n@Injectable()\nexport class GeoMapLayerService {\n  private readonly projection = inject(GeoMapProjectionService);\n  private readonly runtime = new Map<string, GeoMapLayerRuntimeState>();\n\n  getRuntimeState(layerId: string): GeoMapLayerRuntimeState | undefined {\n    return this.runtime.get(layerId);\n  }\n\n  getAllRuntimeStates(): GeoMapLayerRuntimeState[] {\n    return [...this.runtime.values()];\n  }\n\n  createFromBasemapInput(basemap: GeoMapBasemapInput): CreatedMapLayer {\n    if (basemap === 'osm') {\n      const config: GeoMapOsmLayerConfig = {\n        id: GEO_MAP_BASEMAP_LAYER_ID,\n        title: 'OpenStreetMap',\n        type: 'osm',\n        visible: true,\n        opacity: 1,\n        zIndex: 0,\n        basemap: true,\n        group: 'base-map',\n      };\n      return this.createLayer(config);\n    }\n\n    const config: GeoMapXyzLayerConfig = {\n      id: GEO_MAP_BASEMAP_LAYER_ID,\n      title: basemap.title ?? 'XYZ basemap',\n      type: 'xyz',\n      url: basemap.url,\n      attributions: basemap.attributions,\n      maxZoom: basemap.maxZoom,\n      visible: true,\n      opacity: 1,\n      zIndex: 0,\n      basemap: true,\n      group: 'base-map',\n    };\n    return this.createLayer(config);\n  }\n\n  createLayer(config: GeoMapLayerConfig): CreatedMapLayer {\n    this.runtime.set(config.id, { id: config.id, status: 'loading' });\n\n    let layer: BaseLayer;\n    try {\n      this.validateConfig(config);\n      switch (config.type) {\n        case 'osm':\n          layer = this.createOsmLayer(config);\n          break;\n        case 'xyz':\n          layer = this.createXyzLayer(config);\n          break;\n        case 'wms':\n          layer = this.createWmsLayer(config);\n          break;\n        case 'wmts':\n          layer = this.createWmtsLayer(config);\n          break;\n        case 'geojson':\n          layer = this.createGeoJsonLayer(config);\n          break;\n        case 'vector':\n          layer = this.createVectorLayer(config);\n          break;\n        default: {\n          const _exhaustive: never = config;\n          throw new Error(`Unsupported layer type: ${JSON.stringify(_exhaustive)}`);\n        }\n      }\n      this.applyCommonOptions(layer, config);\n      this.wireSourceStatus(config.id, layer);\n      this.runtime.set(config.id, { id: config.id, status: 'ready' });\n    } catch (err) {\n      const message = err instanceof Error ? err.message : String(err);\n      console.error(`[GeoMapLayerService] Failed to create layer \"${config.id}\"`, err);\n      this.runtime.set(config.id, {\n        id: config.id,\n        status: 'error',\n        errorMessage: message,\n      });\n      // Placeholder invisible layer so callers can still track id\n      layer = new VectorLayer({\n        source: new VectorSource(),\n        visible: false,\n      });\n      this.applyCommonOptions(layer, { ...config, visible: false });\n    }\n\n    return { id: config.id, config, layer };\n  }\n\n  /**\n   * Apply visibility/opacity/zIndex without recreating the OL layer.\n   * Returns true when structural fields changed and the layer should be recreated.\n   */\n  needsRecreate(previous: GeoMapLayerConfig, next: GeoMapLayerConfig): boolean {\n    if (previous.type !== next.type || previous.id !== next.id) {\n      return true;\n    }\n    switch (next.type) {\n      case 'osm':\n        return false;\n      case 'xyz':\n        return (\n          (previous as GeoMapXyzLayerConfig).url !== next.url ||\n          (previous as GeoMapXyzLayerConfig).maxZoom !== next.maxZoom\n        );\n      case 'wms':\n        return (\n          (previous as GeoMapWmsLayerConfig).url !== next.url ||\n          JSON.stringify((previous as GeoMapWmsLayerConfig).params) !==\n            JSON.stringify(next.params) ||\n          (previous as GeoMapWmsLayerConfig).layerName !== next.layerName\n        );\n      case 'wmts':\n        return (\n          (previous as GeoMapWmtsLayerConfig).url !== next.url ||\n          (previous as GeoMapWmtsLayerConfig).layer !== next.layer ||\n          (previous as GeoMapWmtsLayerConfig).matrixSet !== next.matrixSet\n        );\n      case 'geojson':\n        return (\n          JSON.stringify((previous as GeoMapGeoJsonLayerConfig).data) !==\n            JSON.stringify(next.data) ||\n          (previous as GeoMapGeoJsonLayerConfig).dataProjection !== next.dataProjection\n        );\n      case 'vector':\n        return (previous as GeoMapVectorLayerConfig).features !== next.features;\n      default:\n        return true;\n    }\n  }\n\n  patchLayer(layer: BaseLayer, config: GeoMapLayerConfig): void {\n    layer.setVisible(config.visible ?? true);\n    layer.setOpacity(config.opacity ?? 1);\n    if (config.zIndex != null) {\n      layer.setZIndex(config.zIndex);\n    }\n    if (config.minZoom != null) {\n      layer.setMinZoom(config.minZoom);\n    }\n    if (config.maxZoom != null) {\n      layer.setMaxZoom(config.maxZoom);\n    }\n    layer.set(LAYER_BASEMAP_KEY, !!config.basemap);\n    layer.set(LAYER_GROUP_KEY, config.group ?? '');\n    layer.set(LAYER_QUERYABLE_KEY, !!config.queryable);\n  }\n\n  setVisible(layer: BaseLayer, visible: boolean): void {\n    layer.setVisible(visible);\n  }\n\n  setOpacity(layer: BaseLayer, opacity: number): void {\n    const clamped = Math.min(1, Math.max(0, opacity));\n    layer.setOpacity(clamped);\n  }\n\n  getLayerId(layer: BaseLayer): string | undefined {\n    const id = layer.get(LAYER_ID_KEY);\n    return typeof id === 'string' ? id : undefined;\n  }\n\n  isBasemap(layer: BaseLayer): boolean {\n    return !!layer.get(LAYER_BASEMAP_KEY);\n  }\n\n  resolveBasemapExclusive(\n    layers: CreatedMapLayer[],\n    activeBasemapId: string,\n  ): void {\n    for (const item of layers) {\n      if (!item.config.basemap) {\n        continue;\n      }\n      const visible = item.id === activeBasemapId;\n      item.layer.setVisible(visible);\n      item.config = { ...item.config, visible };\n    }\n  }\n\n  private validateConfig(config: GeoMapLayerConfig): void {\n    if (!config.id?.trim()) {\n      throw new Error('Layer config requires a non-empty id.');\n    }\n    if (config.type === 'xyz' && !config.url?.trim()) {\n      throw new Error(`XYZ layer \"${config.id}\" is missing url.`);\n    }\n    if (config.type === 'wms') {\n      if (!config.url?.trim()) {\n        throw new Error(`WMS layer \"${config.id}\" is missing url.`);\n      }\n      const layersParam =\n        config.layerName ??\n        (config.params['LAYERS'] != null ? String(config.params['LAYERS']) : '');\n      if (!layersParam) {\n        throw new Error(\n          `WMS layer \"${config.id}\" needs layerName or params.LAYERS.`,\n        );\n      }\n    }\n    if (config.type === 'wmts') {\n      if (!config.url?.trim() || !config.layer?.trim() || !config.matrixSet?.trim()) {\n        throw new Error(\n          `WMTS layer \"${config.id}\" requires url, layer, and matrixSet.`,\n        );\n      }\n    }\n    if (config.type === 'geojson' && config.data == null) {\n      throw new Error(`GeoJSON layer \"${config.id}\" is missing data.`);\n    }\n  }\n\n  private applyCommonOptions(layer: BaseLayer, config: GeoMapLayerConfig): void {\n    layer.set(LAYER_ID_KEY, config.id);\n    layer.set(LAYER_BASEMAP_KEY, !!config.basemap);\n    layer.set(LAYER_GROUP_KEY, config.group ?? '');\n    layer.set(LAYER_QUERYABLE_KEY, !!config.queryable);\n    layer.setVisible(config.visible ?? true);\n    layer.setOpacity(config.opacity ?? 1);\n    if (config.zIndex != null) {\n      layer.setZIndex(config.zIndex);\n    }\n    if (config.minZoom != null) {\n      layer.setMinZoom(config.minZoom);\n    }\n    if (config.maxZoom != null) {\n      layer.setMaxZoom(config.maxZoom);\n    }\n  }\n\n  private wireSourceStatus(layerId: string, layer: BaseLayer): void {\n    if (!(layer instanceof TileLayer)) {\n      return;\n    }\n    const source = layer.getSource();\n    if (!source) {\n      return;\n    }\n\n    source.on('tileloaderror', () => {\n      console.warn(`[GeoMapLayerService] Tile error on layer \"${layerId}\"`);\n      this.runtime.set(layerId, {\n        id: layerId,\n        status: 'error',\n        errorMessage: 'Không tải được dữ liệu lớp bản đồ.',\n      });\n    });\n\n    source.on('tileloadend', () => {\n      const current = this.runtime.get(layerId);\n      if (current?.status === 'error') {\n        return;\n      }\n      this.runtime.set(layerId, { id: layerId, status: 'ready' });\n    });\n  }\n\n  private createOsmLayer(_config: GeoMapOsmLayerConfig): TileLayer<OSM> {\n    return new TileLayer({\n      source: new OSM(),\n    });\n  }\n\n  private createXyzLayer(config: GeoMapXyzLayerConfig): TileLayer<XYZ> {\n    return new TileLayer({\n      source: new XYZ({\n        url: config.url,\n        attributions: config.attributions,\n        maxZoom: config.maxZoom,\n        crossOrigin: config.crossOrigin ?? 'anonymous',\n      }),\n    });\n  }\n\n  private createWmsLayer(config: GeoMapWmsLayerConfig): TileLayer<TileWMS> {\n    const layers =\n      config.layerName ??\n      (config.params['LAYERS'] != null ? String(config.params['LAYERS']) : '');\n    const params: Record<string, string | number | boolean> = {\n      ...config.params,\n      LAYERS: layers,\n    };\n    return new TileLayer({\n      source: new TileWMS({\n        url: config.url,\n        params,\n        serverType: config.serverType,\n        crossOrigin: config.crossOrigin ?? 'anonymous',\n        projection: config.projection as ProjectionLike | undefined,\n      }),\n    });\n  }\n\n  private createWmtsLayer(config: GeoMapWmtsLayerConfig): TileLayer<WMTS> {\n    const projectionCode = config.projection ?? 'EPSG:3857';\n    this.projection.ensureRegistered(projectionCode);\n    const projection = getProjection(projectionCode);\n    if (!projection) {\n      throw new Error(`WMTS projection \"${projectionCode}\" is not available.`);\n    }\n    const projectionExtent = projection.getExtent();\n    if (!projectionExtent) {\n      throw new Error(\n        `WMTS projection \"${projectionCode}\" has no extent; provide a custom tile grid in a later phase.`,\n      );\n    }\n    const size = getWidth(projectionExtent) / 256;\n    const resolutions: number[] = [];\n    const matrixIds: string[] = [];\n    for (let z = 0; z < 20; z += 1) {\n      resolutions[z] = size / Math.pow(2, z);\n      matrixIds[z] = String(z);\n    }\n\n    return new TileLayer({\n      source: new WMTS({\n        url: config.url,\n        layer: config.layer,\n        matrixSet: config.matrixSet,\n        format: config.format ?? 'image/png',\n        style: config.style ?? '',\n        projection: projectionCode,\n        crossOrigin: config.crossOrigin ?? 'anonymous',\n        tileGrid: new WMTSTileGrid({\n          origin: getTopLeft(projectionExtent),\n          resolutions,\n          matrixIds,\n        }),\n      }),\n    });\n  }\n\n  private createGeoJsonLayer(config: GeoMapGeoJsonLayerConfig): VectorLayer<VectorSource> {\n    const format = new GeoJSON();\n    const source = new VectorSource();\n    const featureProjection = config.featureProjection ?? 'EPSG:3857';\n    const dataProjection = config.dataProjection ?? 'EPSG:4326';\n\n    if (typeof config.data === 'string') {\n      // URL — let VectorSource load asynchronously\n      const urlSource = new VectorSource({\n        url: config.data,\n        format: new GeoJSON({\n          dataProjection,\n          featureProjection,\n        }),\n      });\n      urlSource.on('featuresloaderror', () => {\n        console.error(`[GeoMapLayerService] GeoJSON load error \"${config.id}\"`);\n        this.runtime.set(config.id, {\n          id: config.id,\n          status: 'error',\n          errorMessage: 'Không tải được GeoJSON.',\n        });\n      });\n      return new VectorLayer({ source: urlSource });\n    }\n\n    try {\n      const features = format.readFeatures(config.data, {\n        dataProjection,\n        featureProjection,\n      }) as Feature<Geometry>[];\n      source.addFeatures(features);\n    } catch (err) {\n      console.error(`[GeoMapLayerService] Invalid GeoJSON for \"${config.id}\"`, err);\n      throw new Error(`GeoJSON không hợp lệ cho lớp \"${config.id}\".`);\n    }\n\n    return new VectorLayer({ source });\n  }\n\n  private createVectorLayer(config: GeoMapVectorLayerConfig): VectorLayer<VectorSource> {\n    const source = new VectorSource({\n      features: config.features ?? [],\n    });\n    return new VectorLayer({ source });\n  }\n}\n"]}

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

@@ -0,0 +1,110 @@
+import { Injectable } from '@angular/core';
+import { get as getProjection, transform, transformExtent } from 'ol/proj';
+import { register } from 'ol/proj/proj4';
+import proj4 from 'proj4';
+import { GEO_MAP_BUILTIN_PROJECTIONS } from '../geo-map.constants';
+import * as i0 from "@angular/core";
+export class GeoMapProjectionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GeoMapProjectionError';
+    }
+}
+/**
+ * Central proj4 / OpenLayers projection registration and transforms.
+ * Keep all CRS logic here — components must not call proj4 directly.
+ */
+export class GeoMapProjectionService {
+    registeredCodes = new Set(GEO_MAP_BUILTIN_PROJECTIONS);
+    isRegistered(code) {
+        const normalized = this.normalizeCode(code);
+        if (this.registeredCodes.has(normalized)) {
+            return true;
+        }
+        return getProjection(normalized) != null;
+    }
+    /**
+     * Register a custom CRS (e.g. local VN-2000). Definition must come from config/API.
+     */
+    registerProjection(config) {
+        const code = this.normalizeCode(config.code);
+        if (!config.definition?.trim()) {
+            throw new GeoMapProjectionError(`Projection "${code}" is missing a proj4 definition. Supply it from environment or API.`);
+        }
+        try {
+            proj4.defs(code, config.definition.trim());
+            register(proj4);
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            throw new GeoMapProjectionError(`Invalid proj4 definition for "${code}": ${detail}`);
+        }
+        const projection = getProjection(code);
+        if (!projection) {
+            throw new GeoMapProjectionError(`OpenLayers did not create projection "${code}" after registration.`);
+        }
+        if (config.extent) {
+            projection.setExtent(config.extent);
+        }
+        this.registeredCodes.add(code);
+    }
+    ensureRegistered(code) {
+        const normalized = this.normalizeCode(code);
+        if (!this.isRegistered(normalized)) {
+            throw new GeoMapProjectionError(`Projection "${normalized}" is not registered. Call registerProjection() with a valid definition first.`);
+        }
+    }
+    /**
+     * Transform a coordinate. Order is always [x, y] / [longitude, latitude].
+     */
+    transformCoordinate(coordinate, fromProjection, toProjection) {
+        if (coordinate.length < 2) {
+            throw new GeoMapProjectionError('Coordinate must have at least two values [x, y].');
+        }
+        const from = this.normalizeCode(fromProjection);
+        const to = this.normalizeCode(toProjection);
+        this.ensureRegistered(from);
+        this.ensureRegistered(to);
+        if (from === to) {
+            return [Number(coordinate[0]), Number(coordinate[1])];
+        }
+        const result = transform([Number(coordinate[0]), Number(coordinate[1])], from, to);
+        return [result[0], result[1]];
+    }
+    transformExtent(extent, fromProjection, toProjection) {
+        const from = this.normalizeCode(fromProjection);
+        const to = this.normalizeCode(toProjection);
+        this.ensureRegistered(from);
+        this.ensureRegistered(to);
+        if (from === to) {
+            return [...extent];
+        }
+        const result = transformExtent(extent, from, to);
+        return [result[0], result[1], result[2], result[3]];
+    }
+    /**
+     * Normalize user input: trim, upper-case EPSG codes, reject non-finite numbers.
+     */
+    normalizeCoordinate(value, options) {
+        const label = options?.label ?? 'coordinate';
+        if (!Array.isArray(value) || value.length < 2) {
+            throw new GeoMapProjectionError(`Invalid ${label}: expected [x, y] or [longitude, latitude].`);
+        }
+        const x = Number(value[0]);
+        const y = Number(value[1]);
+        if (!Number.isFinite(x) || !Number.isFinite(y)) {
+            throw new GeoMapProjectionError(`Invalid ${label}: values must be finite numbers.`);
+        }
+        return [x, y];
+    }
+    normalizeCode(code) {
+        return code.trim();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GeoMapProjectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GeoMapProjectionService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GeoMapProjectionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geo-map-projection.service.js","sourceRoot":"","sources":["../../../../../../../projects/geo-ui/src/lib/figma/geo-map/services/geo-map-projection.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { get as getProjection, transform, transformExtent } from 'ol/proj';\nimport { register } from 'ol/proj/proj4';\nimport proj4 from 'proj4';\nimport { GEO_MAP_BUILTIN_PROJECTIONS } from '../geo-map.constants';\nimport type { ProjectionConfig } from '../geo-map.types';\n\nexport class GeoMapProjectionError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'GeoMapProjectionError';\n  }\n}\n\n/**\n * Central proj4 / OpenLayers projection registration and transforms.\n * Keep all CRS logic here — components must not call proj4 directly.\n */\n@Injectable({ providedIn: 'root' })\nexport class GeoMapProjectionService {\n  private readonly registeredCodes = new Set<string>(GEO_MAP_BUILTIN_PROJECTIONS);\n\n  isRegistered(code: string): boolean {\n    const normalized = this.normalizeCode(code);\n    if (this.registeredCodes.has(normalized)) {\n      return true;\n    }\n    return getProjection(normalized) != null;\n  }\n\n  /**\n   * Register a custom CRS (e.g. local VN-2000). Definition must come from config/API.\n   */\n  registerProjection(config: ProjectionConfig): void {\n    const code = this.normalizeCode(config.code);\n    if (!config.definition?.trim()) {\n      throw new GeoMapProjectionError(\n        `Projection \"${code}\" is missing a proj4 definition. Supply it from environment or API.`,\n      );\n    }\n\n    try {\n      proj4.defs(code, config.definition.trim());\n      register(proj4);\n    } catch (err) {\n      const detail = err instanceof Error ? err.message : String(err);\n      throw new GeoMapProjectionError(\n        `Invalid proj4 definition for \"${code}\": ${detail}`,\n      );\n    }\n\n    const projection = getProjection(code);\n    if (!projection) {\n      throw new GeoMapProjectionError(\n        `OpenLayers did not create projection \"${code}\" after registration.`,\n      );\n    }\n\n    if (config.extent) {\n      projection.setExtent(config.extent);\n    }\n\n    this.registeredCodes.add(code);\n  }\n\n  ensureRegistered(code: string): void {\n    const normalized = this.normalizeCode(code);\n    if (!this.isRegistered(normalized)) {\n      throw new GeoMapProjectionError(\n        `Projection \"${normalized}\" is not registered. Call registerProjection() with a valid definition first.`,\n      );\n    }\n  }\n\n  /**\n   * Transform a coordinate. Order is always [x, y] / [longitude, latitude].\n   */\n  transformCoordinate(\n    coordinate: [number, number] | number[],\n    fromProjection: string,\n    toProjection: string,\n  ): [number, number] {\n    if (coordinate.length < 2) {\n      throw new GeoMapProjectionError('Coordinate must have at least two values [x, y].');\n    }\n    const from = this.normalizeCode(fromProjection);\n    const to = this.normalizeCode(toProjection);\n    this.ensureRegistered(from);\n    this.ensureRegistered(to);\n\n    if (from === to) {\n      return [Number(coordinate[0]), Number(coordinate[1])];\n    }\n\n    const result = transform(\n      [Number(coordinate[0]), Number(coordinate[1])],\n      from,\n      to,\n    );\n    return [result[0], result[1]];\n  }\n\n  transformExtent(\n    extent: [number, number, number, number],\n    fromProjection: string,\n    toProjection: string,\n  ): [number, number, number, number] {\n    const from = this.normalizeCode(fromProjection);\n    const to = this.normalizeCode(toProjection);\n    this.ensureRegistered(from);\n    this.ensureRegistered(to);\n\n    if (from === to) {\n      return [...extent];\n    }\n\n    const result = transformExtent(extent, from, to);\n    return [result[0], result[1], result[2], result[3]];\n  }\n\n  /**\n   * Normalize user input: trim, upper-case EPSG codes, reject non-finite numbers.\n   */\n  normalizeCoordinate(\n    value: unknown,\n    options?: { label?: string },\n  ): [number, number] {\n    const label = options?.label ?? 'coordinate';\n    if (!Array.isArray(value) || value.length < 2) {\n      throw new GeoMapProjectionError(\n        `Invalid ${label}: expected [x, y] or [longitude, latitude].`,\n      );\n    }\n    const x = Number(value[0]);\n    const y = Number(value[1]);\n    if (!Number.isFinite(x) || !Number.isFinite(y)) {\n      throw new GeoMapProjectionError(`Invalid ${label}: values must be finite numbers.`);\n    }\n    return [x, y];\n  }\n\n  normalizeCode(code: string): string {\n    return code.trim();\n  }\n}\n"]}