@npm9912/v-map 0.1.0

package/dist/collection/components/v-map-layer-wcs/v-map-layer-wcs.js

@@ -0,0 +1,448 @@
+import { h, } from "@stencil/core";
+import { VMapLayerHelper } from "../../layer/v-map-layer-helper";
+import { log } from "../../utils/logger";
+const MSG_COMPONENT = 'v-map-layer-wcs - ';
+export class VMapLayerWcs {
+    el;
+    /** Current load state of the layer. */
+    loadState = 'idle';
+    /** Basis-URL des WCS-Dienstes. */
+    url;
+    /** Coverage-Name/ID. */
+    coverageName;
+    /** Ausgabeformat, z. B. image/tiff. */
+    format = 'image/tiff';
+    /** WCS-Version. */
+    version = '1.1.0';
+    /** Projektion (Projection) für die Quelle. */
+    projection;
+    /** Auflösungen als JSON-Array, z. B. [1000,500]. */
+    resolutions;
+    /** Zusätzliche Parameter als JSON-String. */
+    params;
+    /** Sichtbarkeit des Layers. */
+    visible = true;
+    /** Opazität (0–1). */
+    opacity = 1;
+    /** Z-Index für die Darstellung. */
+    zIndex = 1000;
+    didLoad = false;
+    hasLoadedOnce = false;
+    helper;
+    setLoadState(state) {
+        this.loadState = state;
+    }
+    /** Returns the last error detail, if any. */
+    async getError() {
+        return this.helper?.getError();
+    }
+    componentWillLoad() {
+        log(MSG_COMPONENT + 'componentWillLoad');
+        this.helper = new VMapLayerHelper(this.el, this);
+    }
+    async componentDidLoad() {
+        log(MSG_COMPONENT + 'componentDidLoad');
+        this.helper.startLoading();
+        await this.helper.initLayer(() => this.createLayerConfig(), this.el.id);
+        this.didLoad = true;
+        this.hasLoadedOnce = true;
+    }
+    async connectedCallback() {
+        if (!this.hasLoadedOnce)
+            return;
+        this.helper.startLoading();
+        await this.helper.initLayer(() => this.createLayerConfig(), this.el.id);
+    }
+    async disconnectedCallback() {
+        log(MSG_COMPONENT + 'disconnectedCallback');
+        await this.helper?.dispose();
+    }
+    /** Gibt `true` zurück, sobald der Layer initialisiert wurde. */
+    async isReady() {
+        return this.didLoad;
+    }
+    async onVisibleChanged() {
+        if (!this.didLoad)
+            return;
+        await this.helper?.setVisible(this.visible);
+    }
+    async onOpacityChanged() {
+        if (!this.didLoad)
+            return;
+        await this.helper?.setOpacity(this.opacity);
+    }
+    async onZIndexChanged() {
+        if (!this.didLoad)
+            return;
+        await this.helper?.setZIndex(this.zIndex);
+    }
+    async onSourceChanged() {
+        if (!this.didLoad)
+            return;
+        await this.helper?.updateLayer({
+            type: 'wcs',
+            data: this.createLayerConfig(),
+        });
+    }
+    parseParams() {
+        if (!this.params)
+            return undefined;
+        try {
+            const parsed = JSON.parse(this.params);
+            if (parsed && typeof parsed === 'object') {
+                return parsed;
+            }
+        }
+        catch (error) {
+            this.helper?.setError({ type: 'parse', message: 'Invalid params JSON', attribute: 'params', cause: error });
+        }
+        return undefined;
+    }
+    parseResolutions() {
+        if (!this.resolutions)
+            return undefined;
+        try {
+            const parsed = JSON.parse(this.resolutions);
+            if (Array.isArray(parsed) &&
+                parsed.every(value => typeof value === 'number')) {
+                return parsed;
+            }
+        }
+        catch (error) {
+            this.helper?.setError({ type: 'parse', message: 'Invalid resolutions JSON', attribute: 'resolutions', cause: error });
+        }
+        return undefined;
+    }
+    createLayerConfig() {
+        return {
+            type: 'wcs',
+            url: this.url,
+            coverageName: this.coverageName,
+            format: this.format,
+            version: this.version,
+            projection: this.projection,
+            resolutions: this.parseResolutions(),
+            params: this.parseParams(),
+            visible: this.visible,
+            opacity: this.opacity,
+            zIndex: this.zIndex,
+        };
+    }
+    render() {
+        return h("slot", { key: 'b42cc02537db832f69250cb4545f7c15ce1e5a93' });
+    }
+    static get is() { return "v-map-layer-wcs"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["v-map-layer-wcs.css"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["v-map-layer-wcs.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "loadState": {
+                "type": "string",
+                "mutable": true,
+                "complexType": {
+                    "original": "'idle' | 'loading' | 'ready' | 'error'",
+                    "resolved": "\"error\" | \"idle\" | \"loading\" | \"ready\"",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Current load state of the layer."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "load-state",
+                "defaultValue": "'idle'"
+            },
+            "url": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Basis-URL des WCS-Dienstes."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "url"
+            },
+            "coverageName": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Coverage-Name/ID."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "coverage-name"
+            },
+            "format": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Ausgabeformat, z.\u202FB. image/tiff."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "format",
+                "defaultValue": "'image/tiff'"
+            },
+            "version": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "WCS-Version."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "version",
+                "defaultValue": "'1.1.0'"
+            },
+            "projection": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Projektion (Projection) f\u00FCr die Quelle."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "projection"
+            },
+            "resolutions": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Aufl\u00F6sungen als JSON-Array, z.\u202FB. [1000,500]."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "resolutions"
+            },
+            "params": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Zus\u00E4tzliche Parameter als JSON-String."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "params"
+            },
+            "visible": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Sichtbarkeit des Layers."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "visible",
+                "defaultValue": "true"
+            },
+            "opacity": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Opazit\u00E4t (0\u20131)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "opacity",
+                "defaultValue": "1"
+            },
+            "zIndex": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Z-Index f\u00FCr die Darstellung."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "z-index",
+                "defaultValue": "1000"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "didLoad": {}
+        };
+    }
+    static get methods() {
+        return {
+            "getError": {
+                "complexType": {
+                    "signature": "() => Promise<VMapErrorDetail | undefined>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "VMapErrorDetail": {
+                            "location": "import",
+                            "path": "../../utils/events",
+                            "id": "src/utils/events.ts::VMapErrorDetail",
+                            "referenceLocation": "VMapErrorDetail"
+                        }
+                    },
+                    "return": "Promise<VMapErrorDetail>"
+                },
+                "docs": {
+                    "text": "Returns the last error detail, if any.",
+                    "tags": []
+                }
+            },
+            "isReady": {
+                "complexType": {
+                    "signature": "() => Promise<boolean>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "Gibt `true` zur\u00FCck, sobald der Layer initialisiert wurde.",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "el"; }
+    static get watchers() {
+        return [{
+                "propName": "visible",
+                "methodName": "onVisibleChanged"
+            }, {
+                "propName": "opacity",
+                "methodName": "onOpacityChanged"
+            }, {
+                "propName": "zIndex",
+                "methodName": "onZIndexChanged"
+            }, {
+                "propName": "url",
+                "methodName": "onSourceChanged"
+            }, {
+                "propName": "coverageName",
+                "methodName": "onSourceChanged"
+            }, {
+                "propName": "format",
+                "methodName": "onSourceChanged"
+            }, {
+                "propName": "version",
+                "methodName": "onSourceChanged"
+            }, {
+                "propName": "projection",
+                "methodName": "onSourceChanged"
+            }, {
+                "propName": "resolutions",
+                "methodName": "onSourceChanged"
+            }, {
+                "propName": "params",
+                "methodName": "onSourceChanged"
+            }];
+    }
+}

package/dist/collection/components/v-map-layer-wcs/v-map-layer-wcs.test.js

@@ -0,0 +1,39 @@
+import { afterEach, beforeAll, describe, expect, it } from "vitest";
+import { createLiveMap, createTaggedElement, loadVMapBundle, waitFor, waitForHydration, } from "../../testing/browser-test-utils";
+describe('v-map-layer-wcs browser', () => {
+    beforeAll(async () => {
+        await loadVMapBundle();
+        await customElements.whenDefined('v-map-layer-wcs');
+    });
+    afterEach(() => {
+        document.body.innerHTML = '';
+    });
+    it('hydrates inside a live map and exposes isReady for the browser runtime', async () => {
+        const map = createLiveMap();
+        const group = createTaggedElement('v-map-layergroup');
+        const layer = createTaggedElement('v-map-layer-wcs');
+        layer.setAttribute('url', 'https://example.com/wcs');
+        layer.setAttribute('coverage-name', 'test:elevation');
+        layer.setAttribute('format', 'image/png');
+        layer.setAttribute('version', '2.0.0');
+        layer.visible = false;
+        group.appendChild(layer);
+        map.appendChild(group);
+        document.body.appendChild(map);
+        await waitForHydration(layer);
+        await waitFor(() => typeof layer.isReady === 'function');
+        expect(await layer.isReady()).toBe(true);
+        expect(layer.getAttribute('coverage-name')).toBe('test:elevation');
+        expect(layer.getAttribute('format')).toBe('image/png');
+        expect(layer.getAttribute('version')).toBe('2.0.0');
+        layer.opacity = 0.6;
+        layer.visible = true;
+        layer.zIndex = 200;
+        await waitFor(() => layer.getAttribute('opacity') === '0.6' &&
+            layer.hasAttribute('visible') &&
+            layer.getAttribute('z-index') === '200');
+        expect(layer.getAttribute('opacity')).toBe('0.6');
+        expect(layer.hasAttribute('visible')).toBe(true);
+        expect(layer.getAttribute('z-index')).toBe('200');
+    });
+});

package/dist/collection/components/v-map-layer-wfs/v-map-layer-wfs.css

@@ -0,0 +1 @@
+:host { display: none; }