@npm9912/v-map 0.1.0

package/dist/cjs/v-map-layer-helper-iAzxAg9I.js

@@ -0,0 +1,285 @@
+'use strict';
+
+var messages = require('./messages-D7h4m8Tx.js');
+
+class VMapLayerHelper {
+    el;
+    static RUNTIME_ERROR_DEBOUNCE_MS = 5000;
+    layerId = null;
+    mapProvider = null;
+    _error;
+    host;
+    initContext;
+    listenersBound = false;
+    recreateInFlight = false;
+    lastRuntimeErrorTime = 0;
+    constructor(el, host) {
+        this.el = el;
+        this.host = host;
+    }
+    // ── Error / State management ──────────────────────────────────────
+    startLoading() {
+        // Keep the last error visible during retry until success or new error
+        this.host?.setLoadState('loading');
+    }
+    markReady() {
+        this.clearError();
+        this.host?.setLoadState('ready');
+    }
+    markUpdated() {
+        // Semantically separate success path for updates, currently identical to markReady()
+        this.markReady();
+    }
+    setError(detail) {
+        this._error = detail;
+        this.host?.setLoadState('error');
+        this.el.dispatchEvent(new CustomEvent(messages.VMapEvents.Error, {
+            detail,
+            bubbles: true,
+            composed: true,
+        }));
+        messages.warn(`${this.el.nodeName.toLowerCase()} - ${detail.message}`);
+    }
+    setRuntimeError(detail) {
+        const now = Date.now();
+        if (now - this.lastRuntimeErrorTime < VMapLayerHelper.RUNTIME_ERROR_DEBOUNCE_MS) {
+            return;
+        }
+        this.lastRuntimeErrorTime = now;
+        this.setError(detail);
+    }
+    clearError() {
+        this._error = undefined;
+        this.lastRuntimeErrorTime = 0;
+    }
+    getError() {
+        return this._error;
+    }
+    // ── Layer operations ──────────────────────────────────────────────
+    async addLayer(basemapid, groupId, groupVisible, layerConfig, layerElementId) {
+        if (!this.mapProvider) {
+            messages.warn('Map provider not available.');
+            return null;
+        }
+        if (basemapid) {
+            return await this.mapProvider?.addBaseLayer({
+                ...layerConfig,
+                groupId: groupId,
+                groupVisible: groupVisible,
+            }, basemapid, layerElementId);
+        }
+        return await this.mapProvider?.addLayerToGroup({
+            ...layerConfig,
+            groupId: groupId,
+            groupVisible: groupVisible,
+        });
+    }
+    async addToMapInternal(group, vmap, createLayerConfig, elementId) {
+        if (this.layerId) {
+            this.unregisterLayerError();
+            await this.mapProvider?.removeLayer(this.layerId);
+            this.layerId = null;
+        }
+        const isMapProviderAvailable = (await vmap.isMapProviderReady?.()) === true;
+        if (isMapProviderAvailable) {
+            messages.log(`${this.el.nodeName.toLowerCase()} - layer is being added`);
+            this.mapProvider = vmap.__vMapProvider ?? null;
+            const groupId = await group.getGroupId();
+            const groupVisible = await group.visible;
+            if (this.layerId === null && this.mapProvider) {
+                try {
+                    this.layerId = await this.addLayer(group.basemapid, groupId, groupVisible, createLayerConfig(), elementId);
+                    if (this.layerId) {
+                        this.registerLayerError();
+                        this.markReady();
+                    }
+                    else {
+                        this.setError({
+                            type: 'provider',
+                            message: 'Layer could not be added: provider returned no layer ID',
+                        });
+                    }
+                }
+                catch (e) {
+                    this.setError({
+                        type: 'provider',
+                        message: `Layer could not be added: ${e instanceof Error ? e.message : String(e)}`,
+                        cause: e,
+                    });
+                }
+            }
+        }
+    }
+    // ── Event binding ─────────────────────────────────────────────────
+    bindMapEventsOnce() {
+        if (this.listenersBound || !this.initContext)
+            return;
+        const { vmap } = this.initContext;
+        vmap.addEventListener(messages.VMapEvents.MapProviderReady, this.onMapProviderReady);
+        vmap.addEventListener(messages.VMapEvents.MapProviderWillShutdown, this.onMapProviderWillShutdown);
+        this.listenersBound = true;
+    }
+    onMapProviderReady = async (event) => {
+        messages.log(`${this.el.nodeName.toLowerCase()} - layer add deferred`);
+        const mapEvent = event.detail;
+        this.mapProvider = mapEvent.mapProvider;
+        if (!this.layerId && this.initContext) {
+            this.startLoading();
+            const { group, vmap, createLayerConfig, elementId } = this.initContext;
+            await this.addToMapInternal(group, vmap, createLayerConfig, elementId);
+        }
+    };
+    onMapProviderWillShutdown = async (_event) => {
+        messages.log(`${this.el.nodeName.toLowerCase()} - map provider shutting down`);
+        this.mapProvider = null;
+        this.layerId = null;
+        this.clearError();
+        this.host?.setLoadState('idle');
+    };
+    // ── Mutators ──────────────────────────────────────────────────────
+    async setVisible(visible) {
+        if (!this.layerId || !this.mapProvider) {
+            return;
+        }
+        try {
+            await this.mapProvider.setVisible(this.layerId, visible);
+        }
+        catch (e) {
+            this.setError({
+                type: 'provider',
+                message: `setVisible failed: ${e instanceof Error ? e.message : String(e)}`,
+                cause: e,
+            });
+        }
+    }
+    async setOpacity(opacity) {
+        if (!this.layerId || !this.mapProvider) {
+            return;
+        }
+        try {
+            await this.mapProvider.setOpacity(this.layerId, opacity);
+        }
+        catch (e) {
+            this.setError({
+                type: 'provider',
+                message: `setOpacity failed: ${e instanceof Error ? e.message : String(e)}`,
+                cause: e,
+            });
+        }
+    }
+    async setZIndex(zIndex) {
+        if (!this.layerId || !this.mapProvider) {
+            return;
+        }
+        try {
+            await this.mapProvider.setZIndex(this.layerId, zIndex);
+        }
+        catch (e) {
+            this.setError({
+                type: 'provider',
+                message: `setZIndex failed: ${e instanceof Error ? e.message : String(e)}`,
+                cause: e,
+            });
+        }
+    }
+    async updateLayer(update) {
+        if (!this.layerId || !this.mapProvider) {
+            await this.recreateLayer();
+            return;
+        }
+        try {
+            await this.mapProvider.updateLayer(this.layerId, update);
+            this.markUpdated();
+        }
+        catch (e) {
+            this.setError({
+                type: 'provider',
+                message: `updateLayer failed: ${e instanceof Error ? e.message : String(e)}`,
+                cause: e,
+            });
+        }
+    }
+    // ── Lifecycle ─────────────────────────────────────────────────────
+    async recreateLayer() {
+        if (!this.initContext || this.recreateInFlight)
+            return;
+        this.recreateInFlight = true;
+        this.startLoading();
+        const { group, vmap, createLayerConfig, elementId } = this.initContext;
+        try {
+            await this.addToMapInternal(group, vmap, createLayerConfig, elementId);
+        }
+        finally {
+            this.recreateInFlight = false;
+        }
+    }
+    async initLayer(createLayerConfig, elementId) {
+        const group = this.el.closest('v-map-layergroup');
+        if (!group) {
+            messages.warn(`${this.el.nodeName.toLowerCase()} is not inside a v-map-layergroup`);
+            return;
+        }
+        const vmap = await this.getVMap();
+        if (!vmap) {
+            messages.warn(`No parent v-map component found for ${this.el.nodeName.toLowerCase()}`);
+            return;
+        }
+        this.initContext = { group, vmap, createLayerConfig, elementId };
+        this.bindMapEventsOnce();
+        await this.addToMapInternal(group, vmap, createLayerConfig, elementId);
+    }
+    async dispose() {
+        if (this.initContext && this.listenersBound) {
+            const { vmap } = this.initContext;
+            vmap.removeEventListener(messages.VMapEvents.MapProviderReady, this.onMapProviderReady);
+            vmap.removeEventListener(messages.VMapEvents.MapProviderWillShutdown, this.onMapProviderWillShutdown);
+        }
+        // listenersBound = false enables re-binding on a later connectedCallback()/initLayer()
+        this.listenersBound = false;
+        await this.removeLayer();
+        this.clearError();
+        this.host?.setLoadState('idle');
+    }
+    // ── Accessors ─────────────────────────────────────────────────────
+    getMapProvider() {
+        return this.mapProvider;
+    }
+    getLayerId() {
+        return this.layerId;
+    }
+    async removeLayer() {
+        this.unregisterLayerError();
+        await this.mapProvider?.removeLayer(this.layerId);
+        this.layerId = null;
+    }
+    registerLayerError() {
+        if (this.layerId && this.mapProvider?.onLayerError) {
+            this.mapProvider.onLayerError(this.layerId, (err) => {
+                this.setRuntimeError({
+                    type: err.type,
+                    message: err.message,
+                    cause: err.cause,
+                });
+            });
+        }
+    }
+    unregisterLayerError() {
+        if (this.layerId && this.mapProvider?.offLayerError) {
+            this.mapProvider.offLayerError(this.layerId);
+        }
+    }
+    async getVMap() {
+        messages.log(`${this.el.nodeName.toLowerCase()} - getVMap`);
+        const mapElement = this.el.closest('v-map');
+        if (!mapElement) {
+            messages.log(`${this.el.nodeName.toLowerCase()} - getVMap - v-map not found.`);
+            return null;
+        }
+        await customElements.whenDefined('v-map');
+        const vmap = mapElement;
+        messages.log(`${this.el.nodeName.toLowerCase()} - getVMap - assigned.`);
+        return vmap;
+    }
+}
+
+exports.VMapLayerHelper = VMapLayerHelper;

package/dist/cjs/v-map-layer-terrain-geotiff.cjs.entry.js

@@ -0,0 +1,258 @@
+'use strict';
+
+var index = require('./index-JSwBbvGA.js');
+var vMapLayerHelper = require('./v-map-layer-helper-iAzxAg9I.js');
+var messages = require('./messages-D7h4m8Tx.js');
+
+const vMapLayerTerrainGeotiffCss = () => `:host{display:block}`;
+
+const MSG_COMPONENT = 'v-map-layer-terrain-geotiff - ';
+const VMapLayerTerrainGeotiff = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.ready = index.createEvent(this, "ready", 7);
+    }
+    get el() { return index.getElement(this); }
+    /** Current load state of the layer. */
+    loadState = 'idle';
+    /**
+     * URL to the GeoTIFF file containing elevation data.
+     */
+    url = null;
+    /**
+     * Quell-Projektion des GeoTIFF (z. B. "EPSG:32632" oder proj4-String)
+     */
+    projection = null;
+    /**
+     * Erzwingt die Verwendung der projection-Prop, ignoriert GeoKeys
+     */
+    forceProjection = false;
+    visible = true;
+    /**
+     * Opacity of the terrain layer (0–1).
+     * @default 1
+     */
+    opacity = 1.0;
+    /**
+     * Z-index for layer stacking order. Higher values render on top.
+     */
+    zIndex = 100;
+    /**
+     * NoData value to discard (overriding any nodata values in the metadata).
+     */
+    nodata = null;
+    /**
+     * Mesh error tolerance in meters (Martini).
+     * Smaller values = more detailed mesh, but slower.
+     * @default 4.0
+     */
+    meshMaxError = 4.0;
+    /**
+     * Enable wireframe mode (show only mesh lines).
+     * @default false
+     */
+    wireframe = false;
+    /**
+     * Optional texture URL (can be an image or tile URL).
+     */
+    texture = null;
+    /**
+     * Color for the terrain (if no texture is provided).
+     * [r, g, b] with values 0-255.
+     * @default [255, 255, 255]
+     */
+    color = null;
+    /**
+     * ColorMap for elevation data visualization.
+     * Only relevant when no texture is set.
+     */
+    colorMap = null;
+    /**
+     * Value range for colormap normalization [min, max].
+     */
+    valueRange = null;
+    /**
+     * Elevation exaggeration factor.
+     * @default 1.0
+     */
+    elevationScale = 1.0;
+    /**
+     * Rendering mode for GeoTIFF terrain.
+     * @default terrain
+     */
+    renderMode = 'terrain';
+    /**
+     * Minimum zoom level.
+     */
+    minZoom = 0;
+    /**
+     * Maximum zoom level.
+     */
+    maxZoom = 24;
+    /**
+     * Tile size in pixels.
+     * @default 256
+     */
+    tileSize = 256;
+    /**
+     * Fired when the terrain layer is ready.
+     * @event ready
+     */
+    ready;
+    didLoad = false;
+    hasLoadedOnce = false;
+    helper;
+    setLoadState(state) {
+        this.loadState = state;
+    }
+    /** Returns the last error detail, if any. */
+    async getError() {
+        return this.helper?.getError();
+    }
+    async onUrlChanged() {
+        messages.log(MSG_COMPONENT + 'onUrlChanged');
+        await this.helper?.updateLayer({
+            type: 'terrain-geotiff',
+            data: this.createLayerConfig(),
+        });
+    }
+    async onVisibleChanged() {
+        messages.log(MSG_COMPONENT + 'onVisibleChanged');
+        await this.helper?.setVisible(this.visible);
+    }
+    async onOpacityChanged() {
+        messages.log(MSG_COMPONENT + 'onOpacityChanged');
+        await this.helper?.setOpacity(this.opacity);
+    }
+    async onZIndexChanged() {
+        messages.log(MSG_COMPONENT + 'onZIndexChanged');
+        await this.helper?.setZIndex(this.zIndex);
+    }
+    async onPropertyChanged() {
+        messages.log(MSG_COMPONENT + 'onPropertyChanged');
+        await this.helper?.updateLayer({
+            type: 'terrain-geotiff',
+            data: this.createLayerConfig(),
+        });
+    }
+    isReady() {
+        return this.didLoad;
+    }
+    /**
+     * Returns the internal layer ID used by the map provider.
+     */
+    async getLayerId() {
+        return this.helper.getLayerId();
+    }
+    createLayerConfig() {
+        return {
+            type: 'terrain-geotiff',
+            visible: this.visible,
+            zIndex: this.zIndex,
+            opacity: this.opacity,
+            url: this.url,
+            projection: this.projection,
+            forceProjection: this.forceProjection,
+            nodata: this.nodata,
+            meshMaxError: this.meshMaxError,
+            wireframe: this.wireframe,
+            texture: this.texture,
+            color: this.color,
+            colorMap: this.colorMap,
+            valueRange: this.valueRange,
+            elevationScale: this.elevationScale,
+            renderMode: this.renderMode,
+            minZoom: this.minZoom,
+            maxZoom: this.maxZoom,
+            tileSize: this.tileSize,
+        };
+    }
+    async connectedCallback() {
+        messages.log(MSG_COMPONENT + messages.MESSAGES.COMPONENT_CONNECTED_CALLBACK);
+        if (!this.hasLoadedOnce)
+            return;
+        this.helper.startLoading();
+        await this.helper.initLayer(() => this.createLayerConfig(), this.el.id);
+    }
+    async disconnectedCallback() {
+        messages.log(MSG_COMPONENT + messages.MESSAGES.COMPONENT_DISCONNECTED_CALLBACK);
+        await this.helper?.dispose();
+    }
+    async componentWillLoad() {
+        messages.log(MSG_COMPONENT + messages.MESSAGES.COMPONENT_WILL_LOAD);
+        this.helper = new vMapLayerHelper.VMapLayerHelper(this.el, this);
+    }
+    async componentDidLoad() {
+        messages.log(MSG_COMPONENT + messages.MESSAGES.COMPONENT_DID_LOAD);
+        this.helper.startLoading();
+        await this.helper.initLayer(() => this.createLayerConfig(), this.el.id);
+        this.hasLoadedOnce = true;
+        this.didLoad = true;
+        this.ready.emit();
+    }
+    async componentWillRender() {
+        messages.log(MSG_COMPONENT + messages.MESSAGES.COMPONENT_WILL_RENDER);
+    }
+    render() {
+        return index.h("slot", { key: 'ec36579674879e6def334a8fc18a471aea8f286a' });
+    }
+    static get watchers() { return {
+        "url": [{
+                "onUrlChanged": 0
+            }],
+        "visible": [{
+                "onVisibleChanged": 0
+            }],
+        "opacity": [{
+                "onOpacityChanged": 0
+            }],
+        "zIndex": [{
+                "onZIndexChanged": 0
+            }],
+        "projection": [{
+                "onPropertyChanged": 0
+            }],
+        "forceProjection": [{
+                "onPropertyChanged": 0
+            }],
+        "nodata": [{
+                "onPropertyChanged": 0
+            }],
+        "meshMaxError": [{
+                "onPropertyChanged": 0
+            }],
+        "wireframe": [{
+                "onPropertyChanged": 0
+            }],
+        "texture": [{
+                "onPropertyChanged": 0
+            }],
+        "color": [{
+                "onPropertyChanged": 0
+            }],
+        "colorMap": [{
+                "onPropertyChanged": 0
+            }],
+        "valueRange": [{
+                "onPropertyChanged": 0
+            }],
+        "elevationScale": [{
+                "onPropertyChanged": 0
+            }],
+        "renderMode": [{
+                "onPropertyChanged": 0
+            }],
+        "minZoom": [{
+                "onPropertyChanged": 0
+            }],
+        "maxZoom": [{
+                "onPropertyChanged": 0
+            }],
+        "tileSize": [{
+                "onPropertyChanged": 0
+            }]
+    }; }
+};
+VMapLayerTerrainGeotiff.style = vMapLayerTerrainGeotiffCss();
+
+exports.v_map_layer_terrain_geotiff = VMapLayerTerrainGeotiff;