xv-webcomponents 1.17.19-dev.0 → 1.17.21-qa.0

package/dist/collection/components/xv-geo-map/xv-geo-map.js

@@ -0,0 +1,790 @@
+import { Host, h } from "@stencil/core";
+// Xv.Api wraps responses in { data: ... } (ResponseEnvelopeFilter); the XvGeoTool API returns raw payloads.
+const unwrap = (json) => (json != null && !Array.isArray(json) && 'data' in json ? json.data : json);
+// Germany bounding box (with a small margin) — the map cannot be panned outside
+const GERMANY_BOUNDS = [[4.5, 46.4], [16.5, 55.6]];
+/**
+ * Minimal ATV planner map: MapLibre + PLZ boundaries from the XvGeoTool API.
+ * Click a PLZ to (de)select it. No further UI — selection state and reach
+ * data are emitted via `changeSelection` for the host page to display.
+ *
+ * MapLibre (~250 KB gzip) is loaded lazily when the component scrolls near
+ * the viewport, so the host page's initial load stays untouched.
+ */
+export class XvGeoMap {
+    constructor() {
+        /**
+         * Base URL of the geo API (Xv.Api v1/geo — contract-compatible with the XvGeoTool API).
+         * Default is the same-origin Front Door route, so no CORS is involved on crossvertise pages.
+         */
+        this.apiBase = '/api-fd/v1/geo';
+        /** Indicator whose per-unit values feed the tooltips and the emitted population sum (e.g. ATV_DEVICES) */
+        this.indicator = 'MBI_P_T_2025';
+        /** Unit label shown behind the indicator value in the tooltip */
+        this.indicatorLabel = 'Einwohner';
+        /** Geo level to display and select: plz5, gemeinde, kreis, regbez, bundesland */
+        this.level = 'plz5';
+        /** Shape resolution: medium = simplified geometry (snappy), high = originals */
+        this.resolution = 'medium';
+        /**
+         * Raster tile URL template. Default: CARTO Positron — light, minimal, made for
+         * data overlays; fits the crossvertise design. For production traffic, license
+         * a tile plan (CARTO/MapTiler/Geofabrik) and set the keyed URL here.
+         */
+        this.tiles = 'https://basemaps.cartocdn.com/rastertiles/light_all/{z}/{x}/{y}@2x.png';
+        this.attribution = '© CARTO, © OpenStreetMap contributors';
+        /** Initial map center */
+        this.centerLng = 10.45;
+        this.centerLat = 51.16;
+        this.zoom = 5.5;
+        /** Minimum zoom before boundaries are loaded and selectable (use ~5 for bundesland, 9 for plz5) */
+        this.selectZoom = 9;
+        /** Load the map bundle only when scrolled near the viewport (default: true) */
+        this.lazy = true;
+        this.ready = false;
+        this.loadError = false;
+        this.zoomGated = true;
+        this.initStarted = false;
+        this.readyPromise = new Promise(res => (this.resolveReady = res));
+        this.units = new Map(); // code -> unit, accumulated across viewports
+        this.selected = new Map(); // code -> unit
+        this.populations = new Map(); // code -> indicator value (for tooltips + local sums)
+        this.fetchedBoxes = []; // areas already loaded
+        this.fetchSeq = 0;
+        this.popSeq = 0;
+    }
+    /** switching the level (e.g. PLZ mode -> Bundesländer mode) resets all loaded data and the selection */
+    levelChanged() {
+        if (!this.map)
+            return;
+        this.units.clear();
+        this.selected.clear();
+        this.populations.clear();
+        this.fetchedBoxes = [];
+        this.fetchSeq++;
+        this.renderUnits();
+        this.updateSelectedFilter();
+        this.emitSelection();
+        this.refreshUnits();
+    }
+    selectZoomChanged() {
+        if (!this.map)
+            return;
+        ['units-fill', 'units-hover', 'units-line'].forEach(l => this.map.setLayerZoomRange(l, this.selectZoom, 24));
+        this.refreshUnits();
+    }
+    componentDidLoad() {
+        if (!this.lazy || !('IntersectionObserver' in window)) {
+            this.initMap();
+            return;
+        }
+        this.observer = new IntersectionObserver(entries => {
+            var _a;
+            if (entries.some(e => e.isIntersecting)) {
+                (_a = this.observer) === null || _a === void 0 ? void 0 : _a.disconnect();
+                this.initMap();
+            }
+        }, { rootMargin: '300px' });
+        this.observer.observe(this.el);
+    }
+    disconnectedCallback() {
+        var _a, _b;
+        (_a = this.observer) === null || _a === void 0 ? void 0 : _a.disconnect();
+        (_b = this.map) === null || _b === void 0 ? void 0 : _b.remove();
+    }
+    async initMap() {
+        if (this.initStarted)
+            return;
+        this.initStarted = true;
+        try {
+            const maplibregl = await import('maplibre-gl');
+            const map = new maplibregl.Map({
+                container: this.mapContainer,
+                style: {
+                    version: 8,
+                    sources: {
+                        basemap: {
+                            type: 'raster',
+                            tiles: [this.tiles],
+                            tileSize: 256,
+                            attribution: this.attribution,
+                        },
+                    },
+                    layers: [{ id: 'basemap', type: 'raster', source: 'basemap' }],
+                },
+                center: [this.centerLng, this.centerLat],
+                zoom: this.zoom,
+                minZoom: 5,
+                maxBounds: GERMANY_BOUNDS,
+                attributionControl: { compact: true },
+            });
+            this.map = map;
+            this.el._map = map; // e2e/test handle
+            map.addControl(new maplibregl.NavigationControl({ showCompass: false }));
+            map.on('load', () => {
+                // PLZ boundaries in the XV accent color + dashed, so they are never mistaken
+                // for toner's black road lines on the black/white basemap
+                const accent = getComputedStyle(this.el).getPropertyValue('--link-primary').trim() || '#76b82a';
+                map.addSource('units', { type: 'geojson', data: { type: 'FeatureCollection', features: [] } });
+                // boundary mesh only appears at selectable zoom (cleaner overview);
+                // the selected areas stay visible at every zoom level
+                map.addLayer({
+                    id: 'units-fill',
+                    type: 'fill',
+                    source: 'units',
+                    minzoom: this.selectZoom,
+                    paint: { 'fill-color': accent, 'fill-opacity': 0.04 },
+                });
+                map.addLayer({
+                    id: 'units-selected',
+                    type: 'fill',
+                    source: 'units',
+                    filter: ['in', ['get', 'code'], ['literal', []]],
+                    paint: { 'fill-color': accent, 'fill-opacity': 0.35 },
+                });
+                map.addLayer({
+                    id: 'units-hover',
+                    type: 'fill',
+                    source: 'units',
+                    minzoom: this.selectZoom,
+                    filter: ['==', ['get', 'code'], ''],
+                    paint: { 'fill-color': accent, 'fill-opacity': 0.15 },
+                });
+                map.addLayer({
+                    id: 'units-line',
+                    type: 'line',
+                    source: 'units',
+                    minzoom: this.selectZoom,
+                    paint: { 'line-color': accent, 'line-width': 2, 'line-dasharray': [2, 1.5] },
+                });
+                this.popup = new maplibregl.Popup({
+                    closeButton: false,
+                    closeOnClick: false,
+                    offset: 12,
+                    maxWidth: 'none',
+                    className: 'xv-geo-map-tooltip',
+                });
+                // instant toggle; a double click fires click twice (select + deselect = net zero)
+                // and then zooms, so no debounce delay is needed
+                map.on('click', 'units-fill', e => { var _a, _b, _c; return this.toggleUnit((_c = (_b = (_a = e.features) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.properties) === null || _c === void 0 ? void 0 : _c.code); });
+                map.on('mousemove', 'units-fill', e => {
+                    var _a, _b;
+                    const props = (_b = (_a = e.features) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.properties;
+                    if (!props)
+                        return;
+                    map.getCanvas().style.cursor = 'pointer';
+                    map.setFilter('units-hover', ['==', ['get', 'code'], props.code]);
+                    const pop = this.populations.get(props.code);
+                    const selected = this.selected.has(props.code);
+                    this.popup
+                        .setLngLat(e.lngLat)
+                        .setHTML(`<strong>${props.code}</strong> ${props.name}` +
+                        (pop != null ? `<br>${pop.toLocaleString('de-DE')} ${this.indicatorLabel}` : '') +
+                        (selected ? '<br><em>Klicken zum Abwählen</em>' : '<br><em>Klicken zum Auswählen</em>'))
+                        .addTo(map);
+                });
+                map.on('mouseleave', 'units-fill', () => {
+                    map.getCanvas().style.cursor = '';
+                    map.setFilter('units-hover', ['==', ['get', 'code'], '']);
+                    this.popup.remove();
+                });
+                map.on('moveend', () => this.refreshUnits());
+                this.ready = true;
+                this.mapReady.emit();
+                this.resolveReady();
+                this.refreshUnits();
+            });
+            map.on('error', () => {
+                if (!this.ready)
+                    this.loadError = true;
+            });
+        }
+        catch (_a) {
+            this.loadError = true;
+        }
+    }
+    async refreshUnits() {
+        if (!this.map)
+            return;
+        this.zoomGated = this.map.getZoom() < this.selectZoom;
+        if (this.zoomGated)
+            return;
+        const b = this.map.getBounds();
+        // skip the fetch entirely when the viewport is inside an already-loaded area
+        if (this.fetchedBoxes.some(f => b.getNorth() <= f.n && b.getSouth() >= f.s && b.getEast() <= f.e && b.getWest() >= f.w)) {
+            return;
+        }
+        // fetch with a half-viewport margin so small pans stay within the loaded area
+        const mLat = (b.getNorth() - b.getSouth()) / 2;
+        const mLng = (b.getEast() - b.getWest()) / 2;
+        const box = { n: b.getNorth() + mLat, s: b.getSouth() - mLat, e: b.getEast() + mLng, w: b.getWest() - mLng };
+        const seq = ++this.fetchSeq;
+        try {
+            const res = await fetch(`${this.apiBase}/geo-units/${encodeURIComponent(this.level)}/by-bounds?resolution=${this.resolution}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ north: box.n, south: box.s, east: box.e, west: box.w }),
+            });
+            if (!res.ok || seq !== this.fetchSeq)
+                return;
+            const list = unwrap(await res.json());
+            this.fetchedBoxes.push(box);
+            list.forEach(u => this.units.set(u.code, u));
+            this.renderUnits();
+            this.loadPopulations(list.filter(u => !this.populations.has(u.code)));
+        }
+        catch (_a) {
+            /* viewport fetch failed (offline/CORS) — map stays usable, next moveend retries */
+        }
+    }
+    /** fetch the configured indicator per unit for hover tooltips (fire-and-forget) */
+    async loadPopulations(units) {
+        if (!units.length)
+            return;
+        try {
+            const res = await fetch(`${this.apiBase}/indicators/values`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ geoUnitIds: units.map(u => u.id), indicatorCodes: [this.indicator] }),
+            });
+            if (!res.ok)
+                return;
+            const idToCode = new Map(units.map(u => [u.id, u.code]));
+            for (const v of unwrap(await res.json())) {
+                const code = idToCode.get(v.geoUnitId);
+                if (code)
+                    this.populations.set(code, v.value);
+            }
+        }
+        catch (_a) {
+            /* tooltips just omit population */
+        }
+    }
+    renderUnits() {
+        // render everything loaded so far — panning back never flickers or re-parses
+        const source = this.map.getSource('units');
+        source === null || source === void 0 ? void 0 : source.setData({
+            type: 'FeatureCollection',
+            features: [...this.units.values()].map(u => ({
+                type: 'Feature',
+                properties: { code: u.code, name: u.name },
+                geometry: u.geography,
+            })),
+        });
+    }
+    toggleUnit(code) {
+        if (!code)
+            return;
+        if (this.selected.has(code))
+            this.selected.delete(code);
+        else
+            this.selected.set(code, this.units.get(code));
+        this.updateSelectedFilter();
+        this.emitSelection();
+    }
+    updateSelectedFilter() {
+        this.map.setFilter('units-selected', ['in', ['get', 'code'], ['literal', [...this.selected.keys()]]]);
+    }
+    async emitSelection() {
+        var _a, _b, _c;
+        const postalCodes = [...this.selected.keys()];
+        const unitIds = [...this.selected.values()].map(u => u.id);
+        const seq = ++this.popSeq;
+        // populations are already cached per PLZ (tooltips) — sum locally, emit instantly
+        if (postalCodes.every(c => this.populations.has(c))) {
+            const population = postalCodes.reduce((sum, c) => sum + this.populations.get(c), 0);
+            const selection = { postalCodes, population: postalCodes.length ? population : null, unitIds };
+            this.changeSelection.emit(selection);
+            return selection;
+        }
+        // fallback: some populations not cached yet — aggregate server-side
+        let population = null;
+        try {
+            const res = await fetch(`${this.apiBase}/indicators/aggregate`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ geoUnitIds: unitIds, indicatorCodes: [this.indicator] }),
+            });
+            if (res.ok)
+                population = (_c = (_b = (_a = unwrap(await res.json())) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.sum) !== null && _c !== void 0 ? _c : null;
+        }
+        catch (_d) {
+            /* population stays null — host can fall back */
+        }
+        if (seq !== this.popSeq)
+            return null; // a newer selection superseded this one
+        const selection = { postalCodes, population, unitIds };
+        this.changeSelection.emit(selection);
+        return selection;
+    }
+    // ---- public API for host applications (Angular planner) ----
+    /** Select all PLZs within `km` around a start PLZ ("Umkreis"). Replaces the selection unless `add` is true. */
+    async selectByRadius(startPlz, km, add = false) {
+        await this.ensureReady();
+        const url = `${this.apiBase}/geo-units/${encodeURIComponent(this.level)}/by-radius` +
+            `?address=${encodeURIComponent(startPlz)}&km=${km}&country=DE&resolution=${this.resolution}`;
+        const res = await fetch(url);
+        if (!res.ok)
+            throw new Error(`by-radius failed: HTTP ${res.status}`);
+        return this.applySelection(unwrap(await res.json()), add);
+    }
+    /** Select an explicit list of PLZs ("PLZ-Liste" paste, query-param restore). Replaces the selection unless `add` is true. */
+    async selectPostalCodes(codes, add = false) {
+        await this.ensureReady();
+        const clean = [...new Set(codes.map(c => String(c).trim()).filter(c => /^\d{5}$/.test(c)))];
+        if (!clean.length)
+            return this.applySelection([], add);
+        const res = await fetch(`${this.apiBase}/geo-units/${encodeURIComponent(this.level)}/lookup?resolution=${this.resolution}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ codes: clean }),
+        });
+        if (!res.ok)
+            throw new Error(`lookup failed: HTTP ${res.status}`);
+        return this.applySelection(unwrap(await res.json()), add);
+    }
+    /** Clear the whole selection. */
+    async clearSelection() {
+        await this.ensureReady();
+        this.selected.clear();
+        this.updateSelectedFilter();
+        this.emitSelection();
+    }
+    /** A method call means the map is needed now — start loading even if it hasn't scrolled into view. */
+    ensureReady() {
+        var _a;
+        (_a = this.observer) === null || _a === void 0 ? void 0 : _a.disconnect();
+        this.initMap();
+        return this.readyPromise;
+    }
+    async applySelection(units, add) {
+        if (!add)
+            this.selected.clear();
+        units.forEach(u => {
+            this.units.set(u.code, u);
+            this.selected.set(u.code, u);
+        });
+        this.renderUnits();
+        this.updateSelectedFilter();
+        this.fitToSelection();
+        await this.loadPopulations(units.filter(u => !this.populations.has(u.code)));
+        return this.emitSelection();
+    }
+    fitToSelection() {
+        if (!this.selected.size)
+            return;
+        let minX = 180, minY = 90, maxX = -180, maxY = -90;
+        const scan = (c) => {
+            if (typeof c[0] === 'number') {
+                minX = Math.min(minX, c[0]);
+                maxX = Math.max(maxX, c[0]);
+                minY = Math.min(minY, c[1]);
+                maxY = Math.max(maxY, c[1]);
+            }
+            else
+                c.forEach(scan);
+        };
+        this.selected.forEach(u => scan(u.geography.coordinates));
+        this.map.fitBounds([[minX, minY], [maxX, maxY]], { padding: 48, maxZoom: 12, duration: 800 });
+    }
+    render() {
+        return (h(Host, { key: '82731429f864561b048ba0a21ca719a76286f884' }, h("div", { key: '7e7c074f44ec08595ea2cc5f0142ba52ba84867d', class: "container" }, h("div", { key: '5506193db332fffff278e454bf172897370ecc3a', class: "map", ref: el => (this.mapContainer = el) }), this.ready && this.zoomGated && (h("div", { key: '3db0dbe194852676b055b2a38295f6c47f031bb9', class: "hint" }, "Reinzoomen, um PLZ-Gebiete zu laden")), !this.ready && !this.loadError && (h("div", { key: 'bb26b9d1ca563095d27b0628758fabe7f1b76ec6', class: "skeleton", "aria-busy": "true" }, h("xv-loader-v2", { key: '8f1ec44838087a24467fda2b7e7f32148c42e4ff', variant: "vertical" }, "Karte wird geladen \u2026"))), this.loadError && h("div", { key: 'b352ea83fb5a2be51754aefe4443dca665ae2499', class: "skeleton error" }, "Karte konnte nicht geladen werden."))));
+    }
+    static get is() { return "xv-geo-map-v2"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["xv-geo-map.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["xv-geo-map.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "apiBase": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Base URL of the geo API (Xv.Api v1/geo \u2014 contract-compatible with the XvGeoTool API).\nDefault is the same-origin Front Door route, so no CORS is involved on crossvertise pages."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "api-base",
+                "defaultValue": "'/api-fd/v1/geo'"
+            },
+            "indicator": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Indicator whose per-unit values feed the tooltips and the emitted population sum (e.g. ATV_DEVICES)"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "indicator",
+                "defaultValue": "'MBI_P_T_2025'"
+            },
+            "indicatorLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Unit label shown behind the indicator value in the tooltip"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "indicator-label",
+                "defaultValue": "'Einwohner'"
+            },
+            "level": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Geo level to display and select: plz5, gemeinde, kreis, regbez, bundesland"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "level",
+                "defaultValue": "'plz5'"
+            },
+            "resolution": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "'medium' | 'high'",
+                    "resolved": "\"high\" | \"medium\"",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Shape resolution: medium = simplified geometry (snappy), high = originals"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "resolution",
+                "defaultValue": "'medium'"
+            },
+            "tiles": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Raster tile URL template. Default: CARTO Positron \u2014 light, minimal, made for\ndata overlays; fits the crossvertise design. For production traffic, license\na tile plan (CARTO/MapTiler/Geofabrik) and set the keyed URL here."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "tiles",
+                "defaultValue": "'https://basemaps.cartocdn.com/rastertiles/light_all/{z}/{x}/{y}@2x.png'"
+            },
+            "attribution": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "attribution",
+                "defaultValue": "'\u00A9 CARTO, \u00A9 OpenStreetMap contributors'"
+            },
+            "centerLng": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Initial map center"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "center-lng",
+                "defaultValue": "10.45"
+            },
+            "centerLat": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "center-lat",
+                "defaultValue": "51.16"
+            },
+            "zoom": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "zoom",
+                "defaultValue": "5.5"
+            },
+            "selectZoom": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Minimum zoom before boundaries are loaded and selectable (use ~5 for bundesland, 9 for plz5)"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "select-zoom",
+                "defaultValue": "9"
+            },
+            "lazy": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Load the map bundle only when scrolled near the viewport (default: true)"
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "lazy",
+                "defaultValue": "true"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "ready": {},
+            "loadError": {},
+            "zoomGated": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "changeSelection",
+                "name": "changeSelection",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Selection changed: selected PLZs + population sum of the selection"
+                },
+                "complexType": {
+                    "original": "GeoMapSelection",
+                    "resolved": "GeoMapSelection",
+                    "references": {
+                        "GeoMapSelection": {
+                            "location": "local",
+                            "path": "/home/vsts/work/1/s/src/components/xv-geo-map/xv-geo-map.tsx",
+                            "id": "src/components/xv-geo-map/xv-geo-map.tsx::GeoMapSelection"
+                        }
+                    }
+                }
+            }, {
+                "method": "mapReady",
+                "name": "mapReady",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Map finished initializing"
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "selectByRadius": {
+                "complexType": {
+                    "signature": "(startPlz: string, km: number, add?: boolean) => Promise<GeoMapSelection | null>",
+                    "parameters": [{
+                            "name": "startPlz",
+                            "type": "string",
+                            "docs": ""
+                        }, {
+                            "name": "km",
+                            "type": "number",
+                            "docs": ""
+                        }, {
+                            "name": "add",
+                            "type": "boolean",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "GeoMapSelection": {
+                            "location": "local",
+                            "path": "/home/vsts/work/1/s/src/components/xv-geo-map/xv-geo-map.tsx",
+                            "id": "src/components/xv-geo-map/xv-geo-map.tsx::GeoMapSelection"
+                        }
+                    },
+                    "return": "Promise<GeoMapSelection>"
+                },
+                "docs": {
+                    "text": "Select all PLZs within `km` around a start PLZ (\"Umkreis\"). Replaces the selection unless `add` is true.",
+                    "tags": []
+                }
+            },
+            "selectPostalCodes": {
+                "complexType": {
+                    "signature": "(codes: string[], add?: boolean) => Promise<GeoMapSelection | null>",
+                    "parameters": [{
+                            "name": "codes",
+                            "type": "string[]",
+                            "docs": ""
+                        }, {
+                            "name": "add",
+                            "type": "boolean",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "GeoMapSelection": {
+                            "location": "local",
+                            "path": "/home/vsts/work/1/s/src/components/xv-geo-map/xv-geo-map.tsx",
+                            "id": "src/components/xv-geo-map/xv-geo-map.tsx::GeoMapSelection"
+                        }
+                    },
+                    "return": "Promise<GeoMapSelection>"
+                },
+                "docs": {
+                    "text": "Select an explicit list of PLZs (\"PLZ-Liste\" paste, query-param restore). Replaces the selection unless `add` is true.",
+                    "tags": []
+                }
+            },
+            "clearSelection": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Clear the whole selection.",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "el"; }
+    static get watchers() {
+        return [{
+                "propName": "level",
+                "methodName": "levelChanged"
+            }, {
+                "propName": "selectZoom",
+                "methodName": "selectZoomChanged"
+            }];
+    }
+}