@provoly/dashboard 0.11.0

package/esm2022/widgets/widget-map/component/widget-map.component.mjs

@@ -0,0 +1,822 @@
+import { OverlayConfig } from '@angular/cdk/overlay';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { Component, TemplateRef, ViewChild, ViewContainerRef } from '@angular/core';
+import { ClassSelectors, ConfigActions, ConfigSelectors, ContextMenuActions, DashboardActions, DashboardSelectors, DataSourceSelectors, DataWidgetComponent, FieldSelectors, GeoMetadata, ItemUtils, ResultsetUtils, TooltipMode, WIDGET_HEADER_HEIGHT, widgetMapConfig } from '@provoly/dashboard';
+import equal from 'fast-deep-equal/es6';
+import { Map, Overlay, View } from 'ol';
+import LayerSwitcher from 'ol-layerswitcher';
+import { apply } from 'ol-mapbox-style';
+import { Attribution, ScaleLine } from 'ol/control';
+import { boundingExtent, createEmpty } from 'ol/extent';
+import { Tile } from 'ol/layer';
+import { fromLonLat, get as getProjection, toLonLat, transform } from 'ol/proj';
+import { register } from 'ol/proj/proj4';
+import { TileWMS } from 'ol/source';
+import proj4 from 'proj4';
+import { BehaviorSubject, combineLatest, debounceTime, delay, distinctUntilChanged, filter, from, map, mergeMap, of, startWith, tap } from 'rxjs';
+import { SelectionInteraction } from '../interaction/selection-interaction.class';
+import { MapFormatsReader } from '../reader/map-formats-reader.class';
+import { AddressSearchedEvent, SearchBarControl } from '../search-bar/search-bar.control';
+import { DEFAULT_MAP_CENTER, DEFAULT_ZOOM_MAX, DEFAULT_ZOOM_MIN, DEFAULT_ZOOM_START, exportMapAsGeoJSON, exportMapAsImage, exportMapAsKML, getLinkFeature, getMapAsPng, populateIntensityAttribute, populateLocationAttribute } from '../utils/widget-map.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@provoly/dashboard";
+import * as i3 from "@angular/cdk/overlay";
+import * as i4 from "./widget-map-layer.service";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/forms";
+import * as i7 from "@provoly/dashboard/components/checkbox";
+import * as i8 from "../style/css.component";
+import * as i9 from "../pipe/widget-map-geometry-fields-for.pipe";
+import * as i10 from "../pipe/widget-map-legend-url.pipe";
+export class WidgetMapComponent extends DataWidgetComponent {
+    constructor(store, snackBar, translateService, tooltipFactoryService, geocodingService, overlay, viewContainerRef, symbolService, injector, widgetMapLayerService, el) {
+        super(store, el);
+        this.snackBar = snackBar;
+        this.translateService = translateService;
+        this.tooltipFactoryService = tooltipFactoryService;
+        this.geocodingService = geocodingService;
+        this.overlay = overlay;
+        this.viewContainerRef = viewContainerRef;
+        this.symbolService = symbolService;
+        this.injector = injector;
+        this.widgetMapLayerService = widgetMapLayerService;
+        this.layerTypes = this.widgetMapLayerService.implementationList.sort((a, b) => this.translateService
+            .instant('@pry.widget.map.layerType.' + a)
+            .localeCompare(this.translateService.instant('@pry.widget.map.layerType.' + b)));
+        this.optionsCopy = {};
+        this.selectionInteraction = new SelectionInteraction();
+        this.additionalLayers$ = new BehaviorSubject([]);
+        this.WIDGET_HEADER_HEIGHT = WIDGET_HEADER_HEIGHT;
+        this.i = 0;
+        this.actions$ = widgetMapConfig.actions$;
+        this.classicFeatures$ = new BehaviorSubject([]);
+        this.legendTabOpen = false;
+        this.legendTab = 0;
+        this.imageNotProvided = [];
+        this.zoomAndCenter$ = new BehaviorSubject({});
+        this.basicActions$ = this.actions$.pipe(map((actions) => actions.filter((action) => action !== 'export' && action !== 'upload')));
+        this.classes$ = this.store
+            .select(ClassSelectors.classes)
+            .pipe(map((classes) => classes.sort((a, b) => a.name.localeCompare(b.name))));
+        this.fields$ = this.store.select(FieldSelectors.fields);
+        this.styles$ = this.store.select(ConfigSelectors.mapStyles).pipe(map((styles) => styles.concat({
+            identifier: 'none',
+            label: this.translateService.instant('@pry.widget.map.noStyle')
+        })));
+        this.selectedIds$ = this.store.select(DashboardSelectors.selectedItemIds);
+        this.geoServerLayerDescriptions$ = combineLatest([
+            this.usedDatasources$.pipe(startWith([])),
+            this.store.select(ConfigSelectors.geoServerUrl).pipe(debounceTime(10), startWith(undefined))
+        ]).pipe(map(([dataSources, geoServerUrl]) => {
+            if (!geoServerUrl)
+                return [];
+            return dataSources
+                .filter((ds) => ds.metadata?.find((m) => m.metadataDef.name === GeoMetadata.NAMESPACE) !== undefined)
+                .map((ds) => {
+                ds = ds;
+                const metadatas = {};
+                ds.metadata?.forEach((m) => (metadatas[m.metadataDef.name] = m.value));
+                return {
+                    type: 'geoserver',
+                    url: geoServerUrl + '/' + metadatas[GeoMetadata.NAMESPACE] + '/wms?SERVICE=WMS&VERSION=1.3.0',
+                    paramLayer: metadatas[GeoMetadata.KEY],
+                    paramTiled: true,
+                    opacity: parseInt(metadatas[GeoMetadata.OPACITY] ?? 100, 10),
+                    title: metadatas[GeoMetadata.NAMESPACE] + ':' + metadatas[GeoMetadata.KEY],
+                    oClass: ds.oClass,
+                    key: metadatas[GeoMetadata.NAMESPACE] + ':' + metadatas[GeoMetadata.KEY]
+                };
+            })
+                .map((layer) => layer);
+        }));
+        this.options$ = combineLatest([
+            this.manifest$,
+            this.resultSet$,
+            this.classes$,
+            this.fields$,
+            this.styles$,
+            this.geoServerLayerDescriptions$
+        ]).pipe(map(([manifest, resultSet, classes, fields, mapStyles, geoLayers]) => {
+            // auto determine layers parameters to provide a working view
+            const autoOptions = JSON.parse(JSON.stringify({ relations: true, ...manifest.options }));
+            if (!autoOptions.tooltipMode) {
+                autoOptions.tooltipMode = TooltipMode.HOVER;
+            }
+            if (geoLayers.length > 0) {
+                autoOptions.tooltipMode = TooltipMode.CLICK;
+            }
+            autoOptions.layers?.forEach((layer, i) => {
+                populateLocationAttribute(layer, resultSet, classes, fields);
+                populateIntensityAttribute(layer, resultSet, classes, fields);
+                if (autoOptions.attributions) {
+                    layer.attribution = layer.attribution ?? '';
+                }
+                if (!layer.title) {
+                    this.setDefaultLayerTitle(layer, i);
+                }
+            });
+            const actualLayerKeys = (autoOptions.layers ?? [])
+                .map((layer) => layer.key ?? null)
+                .filter((key) => !!key);
+            // Get all previous layers, without geoserver layers that are not requested anymore, then add new geoserver layers (potentially with a preconfig from manifest).
+            autoOptions.layers = [
+                ...(autoOptions.layers ?? []).map((layer) => {
+                    const geoLayer = geoLayers.find((layer) => layer.key === layer.key) ?? null;
+                    return layer.type === 'geoserver'
+                        ? geoLayer
+                            ? { ...geoLayer, ...layer }
+                            : null
+                        : { ...layer };
+                }),
+                ...geoLayers.filter((layer) => !actualLayerKeys.includes(layer.key))
+            ].filter((layer) => !!layer);
+            if (!!mapStyles &&
+                mapStyles.length > 0 &&
+                (!autoOptions.style || !mapStyles.map((style) => style.identifier).includes(autoOptions.style))) {
+                const lightStyles = mapStyles.filter((style) => !(style.identifier ?? '-').includes('dark'));
+                autoOptions.style = lightStyles.length > 0 ? lightStyles[0].identifier : mapStyles[0].identifier;
+            }
+            return autoOptions;
+        }));
+        this.subscriptions.add(this.options$.pipe(filter((opt) => !!opt)).subscribe((options) => {
+            this.optionsCopy = JSON.parse(JSON.stringify(options));
+        }));
+        this.subscriptions.add(this.store
+            .select(DashboardSelectors.address)
+            .pipe(filter((addr) => !!addr && !!addr.pointAddress))
+            .subscribe((addr) => {
+            this.map?.dispatchEvent(new AddressSearchedEvent({
+                type: 'searched-address',
+                latLon: addr.latLon,
+                coordinates: fromLonLat([...addr.latLon].reverse(), this.map.getView().getProjection()),
+                query: addr.latLon,
+                address: addr.pointAddress
+            }));
+        }));
+        this.mapUrl$ = this.store.select(ConfigSelectors.mapUrl);
+        this.wmsFeatures$ = this.store.select(DashboardSelectors.wmsFeatures);
+        this.bottomLeft$ = combineLatest([this.widgetSize$, this.displayHeader$]).pipe(map(([size, displayHeader]) => `translate(10px ,calc(${size.height}px - 100% - 10px - ${displayHeader ? WIDGET_HEADER_HEIGHT + 'px' : '0px'}))`), delay(10));
+        this.itemStyles$ = combineLatest([this.resultSet$, this.manifest$, this.staticResultSet$]).pipe(mergeMap(([rs, manifest, srs]) => {
+            if ((manifest.datasource === undefined || manifest.datasource.length === 0) && !srs) {
+                return of({});
+            }
+            else {
+                return from(new Promise((resolve, reject) => {
+                    const total = Object.values(rs.items).reduce((p, c) => c.length + p, 0);
+                    if (total === 0)
+                        resolve({});
+                    const result = {};
+                    Object.values(rs.items).forEach((items) => {
+                        items.forEach((item) => Promise.all([
+                            this.symbolService.getSymbolAsIconStyle(item),
+                            this.symbolService.getSymbolAsIconStyle(item, '#8cd560')
+                        ]).then(([style, bStyle]) => {
+                            result[item.id] = { classic: style, bordered: bStyle };
+                            if (Object.keys(result).length >= total) {
+                                resolve(result);
+                            }
+                        }));
+                    });
+                }));
+            }
+        }));
+        this.height$ = combineLatest([this.widgetSize$.pipe(debounceTime(100)), this.displayHeader$]).pipe(map(([size, display]) => (size.height ?? 100) - (display ? WIDGET_HEADER_HEIGHT : 0)), delay(10));
+    }
+    ngAfterViewInit() {
+        this.map$ = combineLatest([this.mapUrl$, this.options$, this.itemStyles$, this.widgetSize$]).pipe(debounceTime(300), mergeMap(([mapUrl, options, rs]) => {
+            if (!this.map) {
+                this.map = new Map({ target: this.mapRef.nativeElement });
+            }
+            this.map.setTarget(undefined);
+            const rect = this.mapRef.nativeElement.getBoundingClientRect();
+            if (rect.height === 0 || rect.width === 0) {
+                console.warn('Map size problem. Resize map');
+            }
+            let mapPromise = new Promise((resolve) => resolve(this.map));
+            if (options.style !== 'none') {
+                mapPromise = apply(this.map, `${mapUrl}/styles/${options.style}/style.json`);
+            }
+            return from(mapPromise).pipe(tap((map) => {
+                this.map.setTarget(this.mapRef.nativeElement);
+                this.map.setView(new View({
+                    center: fromLonLat(options.center ?? DEFAULT_MAP_CENTER),
+                    maxZoom: options.zoom?.max ?? DEFAULT_ZOOM_MAX,
+                    minZoom: options.zoom?.min ?? DEFAULT_ZOOM_MIN,
+                    zoom: options.zoom?.start ?? DEFAULT_ZOOM_START
+                }));
+                if (!options.attributions) {
+                    this.map.getControls().forEach((control) => {
+                        if (control instanceof Attribution) {
+                            this.map.removeControl(control);
+                        }
+                    });
+                }
+                this.map.addInteraction(this.selectionInteraction.init(this.store));
+                this.addContextMenuInteraction();
+                this.addDropInteraction();
+                this.addOverlayOnHoverInteraction();
+                this.addSearchBarControl();
+                this.addLayerSwitcher();
+                this.addScaleControl();
+                this.addUpdateZoomAndCenter();
+                this.fitMapForObjects(options);
+            }));
+        }));
+        this.layers$ = combineLatest([
+            this.resultSet$,
+            this.usedDatasources$,
+            this.options$,
+            this.classes$,
+            this.additionalLayers$,
+            this.itemStyles$,
+            this.store.select(ConfigSelectors.geoServerUrl),
+            this.map$
+        ]).pipe(filter(([resultSet, dataSources, options, classes, additionalLayers, itemStyles, geoServerUrl, map]) => !!resultSet && !!options && !!classes && !!map), map(([resultSet, dataSources, options, classes, additionalLayers, itemStyles, geoServerUrl]) => {
+            let hasRelationLayer = null;
+            const layers = (options?.layers || [])
+                .filter(
+            // @ts-ignore
+            (layer) => this.widgetMapLayerService.dontNeedLocation.includes(layer.type) || !!layer.attribute)
+                .filter(
+            // @ts-ignore
+            (layer) => this.widgetMapLayerService.dontNeedIntensity.includes(layer.type) || !!layer.intensityAttribute)
+                .map((layer, idx) => {
+                const attributesForClass = Object.keys(resultSet.items)
+                    .map((classId) => ({
+                    classId,
+                    ...this.getAttributesForDrawing(classes, classId, layer)
+                }))
+                    .reduce((p, c) => ({
+                    ...p,
+                    [c.classId]: c
+                }), {});
+                let layerClassesId = classes.map((clazz) => clazz.id);
+                if ('classes' in layer && !!layer.classes && layer.classes.length > 0) {
+                    layerClassesId = layer.classes;
+                }
+                let range = { min: 0, max: 0 };
+                // @ts-ignore
+                if (!!layer.intensityAttribute) {
+                    const values = Object.keys(resultSet.items)
+                        .map((classId) => resultSet.items[classId].map((item) => ItemUtils.getAttributeCalculatedValue(item, attributesForClass[item.oClass].intensityAttribute)))
+                        .reduce((p, c) => [...p, ...c], [])
+                        .filter((value) => !!value && typeof value === 'number');
+                    range = values.reduce((p, c) => ({ min: Math.min(p.min, c), max: Math.max(p.max, c) }), {
+                        min: Number.MAX_VALUE,
+                        max: -Number.MAX_VALUE
+                    });
+                }
+                const impl = this.widgetMapLayerService.layersImplementation[layer.type];
+                if (!!impl) {
+                    const resultLayer = impl(layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, this.map);
+                    if (layer.type === 'relation') {
+                        hasRelationLayer = resultLayer;
+                    }
+                    resultLayer.set('title', layer.title);
+                    return resultLayer;
+                }
+                else {
+                    console.error(`Layer type ${layer.type} is unknown`);
+                    return null;
+                }
+            })
+                .filter((layer) => !!layer);
+            if (!!hasRelationLayer) {
+                const features = layers
+                    .filter((layer) => !(layer instanceof Tile))
+                    .map((layer) => layer
+                    // @ts-ignore
+                    .getSource()
+                    .getFeatures()
+                    .filter((features) => !!features.get('id') || !!features.get('features')))
+                    .reduce((p, c) => [...p, ...c], []);
+                resultSet.relations.forEach((relation) => {
+                    const source = features.find((f) => f.get('id') === relation.source);
+                    const dest = features.find((f) => f.get('id') === relation.destination);
+                    if (!!source && !!dest) {
+                        hasRelationLayer.getSource()?.addFeature(getLinkFeature(relation, source, dest));
+                    }
+                });
+            }
+            layers.push(...additionalLayers);
+            layers.forEach((layer, index, arr) => layer.set('zIndex', arr.length - index));
+            return layers;
+        }));
+        this.legendLayers$ = this.options$.pipe(map((options) => (options.layers ?? []).filter((layer) => ['geoserver', 'wms'].includes(layer.type))), delay(10));
+        this.subscriptions.add(combineLatest([
+            this.mapUrl$,
+            this.map$,
+            this.layers$,
+            this.options$,
+            this.selectedIds$,
+            this.additionalLayers$
+        ]).subscribe(([mapUrl, map, layers, options, selectedIds]) => {
+            this.map.setLayers(layers);
+            this.map
+                .getAllLayers()
+                .filter((layer) => !(layer instanceof Tile))
+                .forEach((layer) => {
+                layer.getSource()?.getFeatures().forEach((feature) => {
+                    const type = feature.get('type');
+                    if (['bubble', 'marker', 'point', 'line', 'polygon', 'multi-line', 'multi-polygon'].includes(type)) {
+                        feature.setStyle(feature.get(selectedIds.includes(feature.get('id')) ? 'selectedStyle' : 'classicStyle'));
+                    }
+                });
+            });
+            setTimeout(() => {
+                if (options.style !== 'none') {
+                    apply(this.map, `${mapUrl}/styles/${options.style}/style.json`).then((map) => {
+                        this.map.setTarget(this.mapRef.nativeElement);
+                    });
+                }
+                this.fitMapForObjects(options, selectedIds);
+                this.map.updateSize();
+            }, 200);
+        }));
+        this.subscriptions.add(combineLatest([this.wmsFeatures$, this.classicFeatures$]).subscribe(([wmsFeatures, classicFeatures]) => {
+            if (this.map) {
+                const popupOverlay = new Overlay({
+                    element: this.popup.nativeElement,
+                    offset: [9, 9]
+                });
+                this.map.addOverlay(popupOverlay);
+                this.popupContent.clear();
+                const componentPromises = [];
+                wmsFeatures.forEach((value) => {
+                    componentPromises.push(this.generateTooltip(value));
+                });
+                classicFeatures.forEach((value) => {
+                    componentPromises.push(this.generateTooltip(value));
+                });
+                Promise.all(componentPromises).then((promises) => {
+                    const realComponents = promises.filter((component) => !!component);
+                    if (realComponents.length <= 0) {
+                        this.popup.nativeElement.hidden = true;
+                        popupOverlay.setPosition([-9999999999, -9999999999]);
+                    }
+                    else {
+                        this.popup.nativeElement.hidden = false;
+                        popupOverlay.setPosition(wmsFeatures.length > 0 ? wmsFeatures[0].coordinates : classicFeatures[0].coordinates);
+                    }
+                });
+            }
+        }));
+    }
+    initResultSet$() {
+        return combineLatest([
+            this.store.select(DashboardSelectors.resultSets),
+            this.datasourceIds$,
+            this.staticResultSet$,
+            this.store.select(DataSourceSelectors.datasets)
+        ]).pipe(map(([resultSets, resultSetNamesArray, staticResultSet, definitions]) => {
+            if (!!staticResultSet) {
+                return staticResultSet;
+            }
+            const resultSetArray = resultSetNamesArray
+                .filter((rsName) => {
+                const definition = definitions.find((dsd) => dsd.id === rsName);
+                return !definition || !(definition.metadata ?? []).find((meta) => meta.metadataDef.name === '_geoKey');
+            })
+                .map((rsName) => resultSets[rsName ?? ''])
+                .filter((rsName) => !!rsName);
+            return resultSetArray.reduce((rs1, rs2) => ResultsetUtils.mergeResultSets(rs1, rs2), {
+                items: {},
+                relations: [],
+                merged: resultSetArray.length
+            });
+        }), distinctUntilChanged((p, v) => equal(p, v)));
+    }
+    generateTooltip(value) {
+        return new Promise((resolve) => {
+            const component$ = this.tooltipFactoryService.generateTooltip(value.oClass, this.injector, this.popupContent);
+            component$.subscribe((component) => {
+                if (component) {
+                    component.instance.data.item = value.values;
+                    component.instance.popup = this.popup;
+                    resolve(component);
+                }
+                resolve(null);
+            });
+        });
+    }
+    setDefaultLayerTitle(layer, idx) {
+        layer.title = idx + 1 + ' - ' + this.translateService.instant(`@pry.widget.map.layerType.${layer.type}`);
+    }
+    fitMapForObjects(options, selectedIds) {
+        if (!!options?.fit) {
+            let extent = createEmpty();
+            const listOfMarkers = [];
+            this.map
+                .getAllLayers()
+                .filter((layer) => !!layer.getSource && !!layer.getSource() && !!layer.getSource().getFeatures)
+                .forEach((layer) => {
+                layer.getSource().getFeatures().forEach((feature) => {
+                    const id = feature.get('id');
+                    if (!selectedIds || selectedIds.length <= 0 || (selectedIds.length > 0 && selectedIds.includes(id))) {
+                        switch (feature.get('type')) {
+                            case 'heatpoint':
+                            case 'point':
+                            case 'marker':
+                                listOfMarkers.push(feature.getGeometry().getCoordinates());
+                                break;
+                            case 'line':
+                            case 'link':
+                                listOfMarkers.push(...feature.getGeometry().getCoordinates());
+                                break;
+                            case 'polygon':
+                            case 'multi-line':
+                                listOfMarkers.push(...feature.getGeometry().getCoordinates().flat());
+                                break;
+                            case 'multi-polygon':
+                                listOfMarkers.push(...feature.getGeometry().getCoordinates().flat().flat());
+                                break;
+                            default:
+                                listOfMarkers.push(feature.getGeometry().getCenter());
+                        }
+                    }
+                });
+            });
+            const selectedExtent = boundingExtent(listOfMarkers.filter((coord) => !!coord));
+            if (selectedExtent[0] !== Infinity &&
+                selectedExtent[1] !== Infinity &&
+                selectedExtent[2] !== -Infinity &&
+                selectedExtent[3] !== -Infinity) {
+                extent = selectedExtent;
+            }
+            if (extent[0] !== Infinity && extent[1] !== Infinity && extent[2] !== -Infinity && extent[3] !== -Infinity) {
+                this.map.getView().fit(extent, { padding: [20, 20, 70, 70], duration: 200 });
+            }
+        }
+    }
+    addOverlayOnHoverInteraction() {
+        const popupOverlay = new Overlay({
+            element: this.popup.nativeElement,
+            offset: [9, 9]
+        });
+        this.map.addOverlay(popupOverlay);
+        if (this.optionsCopy.tooltipMode !== TooltipMode.NONE) {
+            const tooltip = this.optionsCopy.tooltipMode === TooltipMode.CLICK ? 'singleclick' : 'pointermove';
+            this.map.on(tooltip, (event) => {
+                const values = this.map.getFeaturesAtPixel(event.pixel, { hitTolerance: 5 });
+                const valuesToDisplay = [
+                    ...new Set(values
+                        .map((value) => value.get('id'))
+                        .filter((id) => !!id)
+                        .map((id) => values.find((value) => value.get('id') === id))
+                        .map((value) => ({
+                        oClass: value?.get('oClass'),
+                        coordinates: event.coordinate,
+                        values: value?.getKeys().reduce((p, c) => ({ ...p, [c]: value.get(c) }), {})
+                    })))
+                ];
+                this.classicFeatures$.next(valuesToDisplay);
+                const wmsLayers = this.getWMSLayers();
+                if (wmsLayers) {
+                    this.getFeatureFromServer(wmsLayers, event.coordinate);
+                }
+            });
+        }
+    }
+    addContextMenuInteraction() {
+        if (this.manifest.contextMenu !== false) {
+            this.map.getViewport().addEventListener('contextmenu', (e) => {
+                const mapCoordinates = this.map.getEventPixel(e);
+                const itemId = this.map.forEachFeatureAtPixel(mapCoordinates, (feature) => feature.get('id'));
+                this.store.dispatch(ContextMenuActions.open({
+                    itemId,
+                    clientX: e.clientX,
+                    clientY: e.clientY,
+                    resultSet: Array.isArray(this.manifest.datasource) ? this.manifest.datasource[0] : this.manifest.datasource,
+                    from: 'map',
+                    coordinates: toLonLat(this.map.getCoordinateFromPixel(mapCoordinates), this.map.getView().getProjection()).reverse()
+                }));
+                e.preventDefault();
+            });
+        }
+    }
+    getAttributesForDrawing(classes, classId, layer) {
+        const classObj = classes.find((cl) => cl.id === classId) ?? { attributes: [] };
+        const locationAttribute = this.getLocationAttribute(classObj, layer);
+        const intensityAttribute = this.getIntensityAttribute(classObj, layer);
+        return { locationAttribute, intensityAttribute };
+    }
+    getIntensityAttribute(classObj, layer) {
+        return ((classObj || { attributes: [] }).attributes.find((attr) => attr.name === layer?.intensityAttribute ?? '') ??
+            undefined);
+    }
+    getLocationAttribute(classObj, layer) {
+        const specificLayer = layer;
+        return (classObj.attributes.find((attr) => attr.name === (specificLayer?.attribute ?? []) ?? '') ??
+            undefined);
+    }
+    changeStyle($event) {
+        this.optionsCopy.style = $event;
+    }
+    changeFit($event) {
+        this.optionsCopy.fit = $event;
+    }
+    changeAttributions($event) {
+        this.optionsCopy.attributions = $event;
+        if (this.optionsCopy.attributions) {
+            this.optionsCopy.layers?.forEach((layer) => (layer.attribution = ''));
+        }
+        else {
+            this.optionsCopy.layers?.forEach((layer) => delete layer.attribution);
+        }
+    }
+    changeTooltipMode($event) {
+        this.optionsCopy.tooltipMode = $event === 'hover' ? TooltipMode.HOVER : TooltipMode.CLICK;
+    }
+    addLayer() {
+        if (!this.optionsCopy.layers) {
+            this.optionsCopy.layers = [];
+        }
+        this.optionsCopy.layers.push({ attribute: '' });
+    }
+    changeLayerType($event, i) {
+        if (!this.optionsCopy.layers) {
+            this.optionsCopy.layers = this.optionsCopy.layers ?? [];
+        }
+        this.optionsCopy.layers[i].type = $event;
+        if (this.optionsCopy.layers[i].type === 'wms') {
+            const options = this.optionsCopy.layers[i];
+            options.paramLayer = options.paramLayer ?? '';
+            options.url = options.url ?? '';
+        }
+        if (this.optionsCopy.layers[i].type === 'wmts') {
+            const options = this.optionsCopy.layers[i];
+            options.paramLayer = options.paramLayer ?? '';
+            options.style = options.style ?? '';
+            options.matrixSet = options.matrixSet ?? '';
+            options.url = options.url ?? '';
+        }
+        if (['featurelayer', 'vectortile', 'rastertile'].includes(this.optionsCopy.layers[i].type)) {
+            const options = this.optionsCopy.layers[i];
+            options.url = options.url ?? '';
+        }
+    }
+    changeTitle($event, layer) {
+        layer.title = $event.currentTarget?.value;
+    }
+    emitManifest() {
+        this.manifestModified.emit({
+            widgetIndex: this.widgetIndex,
+            manifest: {
+                ...this.manifest,
+                options: { ...this.optionsCopy, layers: (this.optionsCopy.layers ?? []).filter((layer) => !!layer.type) }
+            }
+        });
+    }
+    changeLocationAttributes($event, layer) {
+        // @ts-ignore
+        layer.attribute = $event;
+    }
+    layerHasIntensity(layer) {
+        return layer;
+    }
+    changeIntensityAttributes($event, layer) {
+        const layer_ = layer;
+        layer_.intensityAttribute = $event;
+    }
+    changeClasses($event, layer) {
+        const specificLayer = layer;
+        specificLayer.classes = $event;
+    }
+    deleteLayer(i) {
+        this.optionsCopy?.layers?.splice(i, 1);
+    }
+    invertLayers(idx, idxWith) {
+        if (!!this.optionsCopy && !!this.optionsCopy.layers) {
+            const tmp = this.optionsCopy.layers[idxWith];
+            this.optionsCopy.layers[idxWith] = this.optionsCopy.layers[idx];
+            this.optionsCopy.layers[idx] = tmp;
+        }
+    }
+    changeUrl($event, layer) {
+        // @ts-ignore
+        layer.url = $event.currentTarget?.value;
+    }
+    changeAttribution($event, layer) {
+        // @ts-ignore
+        layer.attribution = $event.currentTarget?.value;
+    }
+    changeParamLayer($event, layer) {
+        // @ts-ignore
+        layer.paramLayer = $event.currentTarget?.value;
+    }
+    changeParamTiled($event, layer) {
+        layer.paramTiled = $event;
+    }
+    changeMatrixSet($event, layer) {
+        // @ts-ignore
+        layer.matrixSet = $event.currentTarget?.value;
+    }
+    changeParamStyle($event, layer) {
+        // @ts-ignore
+        layer.style = $event.currentTarget?.value;
+    }
+    export(type) {
+        switch (type) {
+            case 'png':
+                exportMapAsImage(this.map, 'map.png');
+                break;
+            case 'kml':
+                exportMapAsKML(this.map, 'map.kml');
+                break;
+            case 'geoJSON':
+                exportMapAsGeoJSON(this.map, 'map.geojson');
+                break;
+            default:
+                console.error('Unknown format');
+        }
+        this.hideExportType();
+    }
+    toImage() {
+        return getMapAsPng(this.map);
+    }
+    import(event) {
+        const reader = new MapFormatsReader(this.map);
+        const input = event instanceof DragEvent ? event.dataTransfer : event.target;
+        if (!!input && !!input.files && input.files.length > 0) {
+            const filename = input.files[0].name;
+            this.snackBar.open({
+                type: 'info',
+                message: this.translateService.instant('@pry.widget.map.importStart', { filename })
+            });
+            reader
+                .decodeFile(input.files[0])
+                .then((layer) => {
+                this.additionalLayers$.next([...this.additionalLayers$.getValue(), layer]);
+                this.snackBar.open({
+                    type: 'success',
+                    message: this.translateService.instant('@pry.widget.map.importOk', { filename })
+                });
+            })
+                .catch((err) => this.snackBar.open({ type: 'error', message: this.translateService.instant(err.msg, err.val) }));
+        }
+        if (!!input && !(input instanceof DataTransfer)) {
+            input.value = null;
+        }
+    }
+    addDropInteraction() {
+        this.map.getViewport().addEventListener('drop', (e) => {
+            this.import(e);
+            e.preventDefault();
+        });
+    }
+    changeClustered(layer, $event) {
+        layer.clustered = $event;
+        if (layer.clustered) {
+            layer.clusterDistance = 10;
+        }
+    }
+    changeClusterDistance(layer, $event) {
+        // @ts-ignore
+        layer.clusterDistance = $event.currentTarget?.value;
+    }
+    addScaleControl() {
+        this.map.addControl(new ScaleLine({
+            units: 'metric',
+            bar: true,
+            steps: 4,
+            text: true,
+            minWidth: 140
+        }));
+    }
+    addSearchBarControl() {
+        this.searchBarControl = new SearchBarControl({}).withGeocodingService(this.geocodingService);
+        this.map.addControl(this.searchBarControl);
+        const addressOverlay = new Overlay({
+            element: this.address.nativeElement,
+            offset: [9, 9]
+        });
+        this.map.addOverlay(addressOverlay);
+        // @ts-ignore
+        this.map.on('searched-address', (evt) => {
+            this.address.nativeElement.innerHTML = `<div>
+        <div>${this.translateService.instant('@pry.widget.map.address')}: ${evt.address}</div>
+        <div>${this.translateService.instant('@pry.widget.map.addressCoords')}: ${evt.latLon}</div>
+        </div>`;
+            this.address.nativeElement.style.display = '';
+            addressOverlay.setPosition(evt.coordinates);
+            this.map.getView().setCenter(evt.coordinates);
+            this.map.getView().setZoom(this.map.getView().getMaxZoom());
+        });
+    }
+    addLayerSwitcher() {
+        this.layerSwitchControl = new LayerSwitcher({
+            activationMode: 'click',
+            reverse: false
+        });
+        this.map.addControl(this.layerSwitchControl);
+        // @ts-ignore
+        this.layerSwitchControl.on('show', () => {
+            this.legendTabOpen = false;
+        });
+    }
+    hideAddress() {
+        this.address.nativeElement.style.display = 'none';
+    }
+    addUpdateZoomAndCenter() {
+        this.map.on('moveend', () => {
+            this.optionsCopy.zoom = {
+                start: this.map.getView().getZoom() ?? this.optionsCopy.zoom?.start ?? this.map.getView().getMinZoom(),
+                min: this.map.getView().getMinZoom(),
+                max: this.map.getView().getMaxZoom()
+            };
+            this.optionsCopy.center = toLonLat(this.map.getView().getCenter() ?? [0, 0]) ?? this.optionsCopy.center;
+            this.zoomAndCenter$.next({ zoom: this.optionsCopy.zoom, center: this.optionsCopy.center });
+        });
+    }
+    changeOpacity(layer, $event) {
+        // @ts-ignore
+        layer.opacity = parseInt($event, 10);
+    }
+    displayExportType($event) {
+        this.overlayRef = this.overlay.create(new OverlayConfig({
+            hasBackdrop: true,
+            panelClass: ['m-context-menu-wrapper'],
+            backdropClass: 'backdrop'
+        }));
+        this.store.dispatch(ConfigActions.addingOverlay({ id: this.constructor.name }));
+        this.overlayRef.backdropClick().subscribe((_) => this.hideExportType());
+        this.overlayRef.attach(new TemplatePortal(this.exportTypeTemplate, this.viewContainerRef));
+        const contextMenu = document.querySelector('div.m-context-menu-wrapper');
+        if (!!contextMenu) {
+            contextMenu.style.left = $event.clientX - 10 + 'px';
+            contextMenu.style.top = $event.clientY - 10 - contextMenu.clientHeight + 'px';
+        }
+    }
+    hideExportType() {
+        this.overlayRef?.dispose();
+        this.store.dispatch(ConfigActions.addingOverlay({ id: this.constructor.name }));
+    }
+    getWMSLayers() {
+        return !this.map
+            ? []
+            : this.map
+                .getAllLayers()
+                .filter((layer) => layer.getSource() instanceof TileWMS)
+                // @ts-ignore
+                .filter((layer) => layer.rendered === true);
+    }
+    isLayerRendered(layer) {
+        return !!this.getWMSLayers().find((wmsLayer) => wmsLayer.get('title') === layer.title);
+    }
+    getFeatureFromServer(wmsLayers, pixel) {
+        proj4.defs('EPSG:2154', '+proj=lcc +lat_0=46.5 +lon_0=3 +lat_1=49 +lat_2=44 +x_0=700000 +y_0=6600000 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs +type=crs');
+        register(proj4);
+        const projGeo = getProjection('EPSG:3857');
+        const projLambert = getProjection('EPSG:2154');
+        if (projLambert && projGeo) {
+            for (const layer of wmsLayers) {
+                const url = layer
+                    .getSource()
+                    .getFeatureInfoUrl(transform(pixel, projGeo, projLambert), this.map.getView().getResolution(), 'EPSG:2154', {
+                    INFO_FORMAT: 'application/json',
+                    FEATURE_COUNT: 10
+                });
+                if (url) {
+                    this.store.dispatch(DashboardActions.getWmsFeatures({
+                        url,
+                        oClass: layer.getProperties().oClass ?? '',
+                        coordinates: pixel
+                    }));
+                }
+            }
+        }
+    }
+    changeWmsClass($event, layer) {
+        layer.oClass = $event;
+    }
+    toggleLegend(index) {
+        this.legendTab = this.legendTab === index ? -1 : index;
+    }
+    toggleLegendWindow() {
+        this.legendTabOpen = !this.legendTabOpen;
+        this.layerSwitchControl?.hidePanel();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: WidgetMapComponent, deps: [{ token: i1.Store }, { token: i2.PrySnackbarService }, { token: i2.PryI18nService }, { token: i2.TooltipFactoryService }, { token: i2.GeocodingService }, { token: i3.Overlay }, { token: i0.ViewContainerRef }, { token: i2.SymbolService }, { token: i0.Injector }, { token: i4.WidgetMapLayerService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.6", type: WidgetMapComponent, selector: "pry-widget-map", viewQueries: [{ propertyName: "mapRef", first: true, predicate: ["map"], descendants: true }, { propertyName: "popup", first: true, predicate: ["popup"], descendants: true }, { propertyName: "popupContent", first: true, predicate: ["popupContent"], descendants: true, read: ViewContainerRef }, { propertyName: "exportTypeTemplate", first: true, predicate: ["exportTypeTemplate"], descendants: true, read: TemplateRef }, { propertyName: "address", first: true, predicate: ["address"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<pry-widget-map-css></pry-widget-map-css>\n<div class=\"o-widget o-widget--map\">\n  <pry-widget-header\n    [datasourceIds$]=\"datasourceIds$\"\n    *ngIf=\"displayHeader$ | async\"\n    [widgetIndex]=\"widgetIndex\"\n    [manifest]=\"manifest\"\n    (manifestModified)=\"manifestModified.emit($event)\"\n    [headerOptions]=\"(displayHeader$ | async) ?? {}\"\n    #header\n  >\n    <pry-settings\n      (saveTriggered)=\"emitManifest()\"\n      [headerPresent]=\"displayHeader$ | async\"\n      [widgetIndex]=\"widgetIndex\"\n      [header]=\"header\"\n      [open$]=\"open$\"\n      class=\"o-settings\"\n    >\n      <div class=\"m-form-label-field\">\n        <label class=\"a-label\" for=\"map_style\">{{ '@pry.widget.map.style' | i18n }}</label>\n        <pry-select\n          (ngModelChange)=\"changeStyle($event)\"\n          [itemsAsOption]=\"true\"\n          [items]=\"styles$ | async\"\n          [ngModel]=\"optionsCopy.style\"\n          bindLabel=\"label\"\n          bindValue=\"identifier\"\n          id=\"map_style\"\n          class=\"a-pry-select\"\n        ></pry-select>\n      </div>\n\n      <pry-checkbox (ngModelChange)=\"changeFit($event)\" [ngModel]=\"optionsCopy.fit ?? false\">\n        {{ '@pry.widget.map.fit' | i18n }}\n      </pry-checkbox>\n\n      <pry-checkbox (ngModelChange)=\"changeAttributions($event)\" [ngModel]=\"optionsCopy.attributions ?? false\">\n        {{ '@pry.widget.map.attributions' | i18n }}\n      </pry-checkbox>\n\n      <fieldset class=\"m-form-radio-group-wrapper\">\n        <legend class=\"a-label\">{{ '@pry.widget.map.tooltip.title' | i18n }}</legend>\n        <div class=\"m-form-radio-group\">\n          <div class=\"m-form-radio-group__item\">\n            <input\n              class=\"a-form-field\"\n              type=\"radio\"\n              id=\"click\"\n              name=\"tooltip\"\n              [ngModel]=\"optionsCopy.tooltipMode\"\n              (ngModelChange)=\"changeTooltipMode('click')\"\n              value=\"click\"\n              [disabled]=\"((geoServerLayerDescriptions$ | async)?.length ?? 0) > 0\"\n            />\n            <label for=\"click\" class=\"a-label\">\n              {{ '@pry.widget.map.tooltip.click' | i18n }}\n            </label>\n          </div>\n          <div class=\"m-form-radio-group__item\">\n            <input\n              class=\"a-form-field\"\n              type=\"radio\"\n              id=\"hover\"\n              name=\"tooltip\"\n              [ngModel]=\"optionsCopy.tooltipMode\"\n              (ngModelChange)=\"changeTooltipMode('hover')\"\n              value=\"hover\"\n              [disabled]=\"((geoServerLayerDescriptions$ | async)?.length ?? 0) > 0\"\n            />\n            <label for=\"hover\" class=\"a-label\">\n              {{ '@pry.widget.map.tooltip.hover' | i18n }}\n            </label>\n          </div>\n        </div>\n      </fieldset>\n\n      <div class=\"o-settings__popup__content__actions -has-separator\">\n        <button type=\"button\" (click)=\"addLayer()\" class=\"a-btn a-btn--icon-text -link-like\">\n          <pry-icon iconSvg=\"library_add\"></pry-icon>\n          {{ '@pry.widget.map.addLayer' | i18n }}\n        </button>\n      </div>\n\n      <div *ngFor=\"let layer of optionsCopy?.layers; let i = index\" class=\"o-settings__popup__content__fields\">\n        <div class=\"o-settings__popup__content__fields__head\">\n          <h3 class=\"a-h3 settings-layer-title__title\">{{ '@pry.widget.map.layer' | i18n: { index: i + 1 } }}</h3>\n          <div class=\"m-btn-group\">\n            <button type=\"button\" class=\"a-btn a-btn--icon-only\" (click)=\"invertLayers(i, i - 1)\" *ngIf=\"i > 0\">\n              <pry-icon iconSvg=\"fleche_haut\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveUp' | i18n }}</span>\n            </button>\n            <button\n              type=\"button\"\n              class=\"a-btn a-btn--icon-only\"\n              (click)=\"invertLayers(i, i + 1)\"\n              *ngIf=\"i < (optionsCopy?.layers?.length ?? 0) - 1\"\n            >\n              <pry-icon iconSvg=\"fleche_bas\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveDown' | i18n }}</span>\n            </button>\n          </div>\n        </div>\n\n        <div class=\"o-settings__popup__content__fields__content\">\n          <pry-range\n            [ngModel]=\"(layer?.opacity ?? 100) + ''\"\n            (ngModelChange)=\"changeOpacity(layer, $event)\"\n            labelTranslate=\"@pry.widget.map.opacity\"\n            min=\"0\"\n            max=\"100\"\n          ></pry-range>\n\n          <fieldset>\n            <legend class=\"u-visually-hidden\">{{ '@pry.widget.map.layerOptions' | i18n: { index: i + 1 } }}</legend>\n            <div class=\"m-form-label-field\">\n              <label class=\"a-label\" for=\"map_layerTitle\">{{ '@pry.widget.map.layerTitle' | i18n }}</label>\n              <input\n                id=\"map_layerTitle\"\n                class=\"a-form-field\"\n                type=\"text\"\n                (input)=\"changeTitle($event, layer)\"\n                [value]=\"layer.title ?? ''\"\n              />\n            </div>\n\n            <div class=\"m-form-label-field\">\n              <label class=\"a-label\" for=\"map_layerType\">{{ '@pry.widget.map.layerType.title' | i18n }}</label>\n              <pry-select\n                (ngModelChange)=\"changeLayerType($event, i)\"\n                [bindData]=\"true\"\n                [itemsAsOption]=\"true\"\n                [items]=\"layerTypes\"\n                [labelTranslate]=\"true\"\n                [ngModel]=\"layer.type\"\n                [disabled]=\"layer.type === 'geoserver'\"\n                baseTranslate=\"@pry.widget.map.layerType.\"\n                class=\"a-pry-select\"\n                id=\"map_layerType\"\n              ></pry-select>\n            </div>\n\n            <div\n              *ngIf=\"\n                layer.type !== 'relation' &&\n                layer.type !== 'wms' &&\n                layer.type !== 'wmts' &&\n                layer.type !== 'geoserver' &&\n                layer.type !== 'featurelayer' &&\n                layer.type !== 'vectortile' &&\n                layer.type !== 'rastertile'\n              \"\n              class=\"m-form-label-field\"\n            >\n              <label class=\"a-label\" for=\"map_classes\">{{ '@pry.widget.map.classes' | i18n }}</label>\n              <pry-select\n                (ngModelChange)=\"changeClasses($event, layer)\"\n                [itemsAsOption]=\"true\"\n                [items]=\"classes$ | async\"\n                [multiple]=\"true\"\n                [ngModel]=\"layer.classes\"\n                bindLabel=\"name\"\n                bindValue=\"id\"\n                class=\"a-pry-select\"\n                id=\"map_classes\"\n              ></pry-select>\n            </div>\n          </fieldset>\n        </div>\n\n        <fieldset\n          *ngIf=\"\n            layer.type !== 'relation' &&\n            layer.type !== 'wms' &&\n            layer.type !== 'wmts' &&\n            layer.type !== 'geoserver' &&\n            layer.type !== 'featurelayer' &&\n            layer.type !== 'vectortile' &&\n            layer.type !== 'rastertile'\n          \"\n        >\n          <legend class=\"u-visually-hidden\">{{ '@pry.widget.map.locationAttr' | i18n }}</legend>\n          <ng-container\n            *ngIf=\"\n              layer\n                | geometryFieldsFor: { resultSet: resultSet$, classes: layer.classes, type: layer.type }\n                | async as fields\n            \"\n          >\n            <div\n              *ngIf=\"\n                ['heatmap', 'bubble', 'marker', 'point', 'line', 'polygon', 'multi-line', 'multi-polygon'].indexOf(\n                  layer.type\n                ) >= 0\n              \"\n            >\n              <div class=\"m-form-label-field\">\n                <label class=\"a-label\" for=\"map_locationAttribute_both\">{{\n                  '@pry.widget.map.locationAttribute.both' | i18n\n                }}</label>\n                <pry-select\n                  (ngModelChange)=\"changeLocationAttributes($event, layer)\"\n                  [itemsAsOption]=\"true\"\n                  [items]=\"fields\"\n                  [ngModel]=\"layer.attribute\"\n                  bindLabel=\"name\"\n                  bindValue=\"name\"\n                  id=\"map_locationAttribute_both\"\n                  class=\"a-pry-select\"\n                ></pry-select>\n              </div>\n            </div>\n\n            <div *ngIf=\"['heatmap', 'bubble'].indexOf(layer.type) >= 0\">\n              <div class=\"m-form-label-field\">\n                <label class=\"a-label\" for=\"map_intensityAttribute\">{{\n                  '@pry.widget.map.intensityAttribute' | i18n\n                }}</label>\n                <pry-select\n                  (ngModelChange)=\"changeIntensityAttributes($event, layer)\"\n                  [itemsAsOption]=\"true\"\n                  [items]=\"fields\"\n                  [ngModel]=\"layerHasIntensity(layer).intensityAttribute\"\n                  bindLabel=\"name\"\n                  bindValue=\"name\"\n                  id=\"map_intensityAttribute\"\n                  class=\"a-pry-select\"\n                ></pry-select>\n              </div>\n            </div>\n          </ng-container>\n        </fieldset>\n\n        <fieldset\n          *ngIf=\"\n            layer.type === 'wms' ||\n            layer.type === 'geoserver' ||\n            layer.type === 'wmts' ||\n            layer.type === 'featurelayer' ||\n            layer.type === 'vectortile' ||\n            layer.type === 'rastertile'\n          \"\n        >\n          <legend class=\"u-visually-hidden\">{{ '@pry.widget.map.tile' | i18n }}</legend>\n          <div class=\"m-form-label-field\">\n            <label class=\"a-label\" for=\"map_wms_url\">{{ '@pry.widget.map.wms.url' | i18n }}</label>\n            <input\n              id=\"map_wms_url\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeUrl($event, layer)\"\n              [disabled]=\"layer.type === 'geoserver'\"\n              [value]=\"layer.url\"\n            />\n          </div>\n\n          <div\n            class=\"m-form-label-field\"\n            *ngIf=\"layer.type === 'wms' || layer.type === 'geoserver' || layer.type === 'wmts'\"\n          >\n            <label class=\"a-label\" for=\"map_wms_paramLayer\">{{ '@pry.widget.map.wms.paramLayer' | i18n }}</label>\n            <input\n              id=\"map_wms_paramLayer\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeParamLayer($event, layer)\"\n              [disabled]=\"layer.type === 'geoserver'\"\n              [value]=\"layer.paramLayer\"\n            />\n          </div>\n\n          <div class=\"m-form-label-field\" *ngIf=\"layer.type === 'wmts'\">\n            <label class=\"a-label\" for=\"map_wms_matrixSet\">{{ '@pry.widget.map.wms.matrixSet' | i18n }}</label>\n            <input\n              id=\"map_wms_matrixSet\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeMatrixSet($event, layer)\"\n              [value]=\"layer.matrixSet\"\n            />\n          </div>\n\n          <div class=\"m-form-label-field\" *ngIf=\"layer.type === 'wmts'\">\n            <label class=\"a-label\" for=\"map_wms_style\">{{ '@pry.widget.map.wms.style' | i18n }}</label>\n            <input\n              id=\"map_wms_style\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeParamStyle($event, layer)\"\n              [value]=\"layer.style\"\n            />\n          </div>\n\n          <div class=\"m-form-label-field\" *ngIf=\"layer.type === 'wms'\">\n            <pry-checkbox (ngModelChange)=\"changeParamTiled($event, layer)\" [ngModel]=\"layer?.paramTiled ?? false\">\n              {{ '@pry.widget.map.wms.paramTiled' | i18n }}\n            </pry-checkbox>\n          </div>\n        </fieldset>\n\n        <fieldset *ngIf=\"layer.type === 'marker'\">\n          <legend class=\"u-visually-hidden\">{{ '@pry.widget.map.clustering' | i18n }}</legend>\n          <div class=\"m-form-label-field\">\n            <pry-checkbox (ngModelChange)=\"changeClustered(layer, $event)\" [ngModel]=\"layer.clustered\">\n              {{ '@pry.widget.map.clustered' | i18n }}\n            </pry-checkbox>\n          </div>\n          <div *ngIf=\"layer.clustered\">\n            <pry-range\n              [ngModel]=\"layer.clustered\"\n              (ngModelChange)=\"changeClusterDistance(layer, $event)\"\n              labelTranslate=\"@pry.widget.map.clusterDistance\"\n              min=\"1\"\n              max=\"500\"\n            ></pry-range>\n          </div>\n        </fieldset>\n\n        <div class=\"m-form-label-field\" *ngIf=\"optionsCopy.attributions\">\n          <label class=\"a-label\" for=\"attribution\">{{ '@pry.widget.map.attribution' | i18n }}</label>\n          <input\n            id=\"attribution\"\n            class=\"a-form-field\"\n            type=\"text\"\n            (input)=\"changeAttribution($event, layer)\"\n            [value]=\"layer.attribution ? layer.attribution : ''\"\n          />\n        </div>\n\n        <button\n          type=\"button\"\n          (click)=\"deleteLayer(i)\"\n          class=\"a-btn a-btn--icon-text -link-like\"\n          *ngIf=\"layer.type !== 'geoserver'\"\n          data-func=\"delete\"\n        >\n          <pry-icon iconSvg=\"delete\" [width]=\"19\" [height]=\"19\"></pry-icon>\n          <span>{{ '@pry.widget.map.deleteLayer' | i18n }}</span>\n        </button>\n      </div>\n    </pry-settings>\n  </pry-widget-header>\n\n  <div class=\"m-btn-group -selection-choice\" [style.transform]=\"bottomLeft$ | async\">\n    <ng-container *ngFor=\"let action of basicActions$ | async\">\n      <button\n        type=\"button\"\n        class=\"a-btn a-btn--icon-only\"\n        (click)=\"selectionInteraction.changeSelection(action)\"\n        [class.-selected]=\"selectionInteraction.selectionType === action\"\n        [pryTooltip]=\"infoTooltipAction\"\n        pryTooltipPosition=\"bottom\"\n        aria-describedby=\"infoTooltipAction\"\n        [pryTooltipContext]=\"{ action: action }\"\n      >\n        <pry-icon [iconSvg]=\"action\"></pry-icon>\n        <span class=\"u-visually-hidden\">{{ '@pry.widget.map.' + action | i18n }}</span>\n      </button>\n    </ng-container>\n\n    <button\n      type=\"button\"\n      class=\"a-btn a-btn--icon-only\"\n      id=\"export_card\"\n      aria-expanded=\"false\"\n      aria-controls=\"export_type\"\n      aria-haspopup=\"menu\"\n      [pryTooltip]=\"infoTooltipDown\"\n      pryTooltipPosition=\"bottom\"\n      aria-describedby=\"infoTooltipDown_widgetMap\"\n      *ngIf=\"(actions$ | async)?.includes('export')\"\n    >\n      <pry-icon iconSvg=\"file_download\" (click)=\"displayExportType($event)\"></pry-icon>\n      <span class=\"u-visually-hidden\">{{ '@pry.widget.map.export' | i18n }}</span>\n    </button>\n\n    <button\n      type=\"button\"\n      class=\"a-btn a-btn--icon-only\"\n      (click)=\"uploader.click()\"\n      [pryTooltip]=\"infoTooltipLoad\"\n      aria-describedby=\"infoTooltipLoad_widgetMap\"\n      pryTooltipPosition=\"bottom\"\n      *ngIf=\"(actions$ | async)?.includes('upload')\"\n    >\n      <pry-icon iconSvg=\"file_upload\"></pry-icon>\n      <span class=\"u-visually-hidden\">{{ '@pry.widget.map.import' | i18n }}</span>\n    </button>\n    <input hidden type=\"file\" #uploader (change)=\"import($event)\" />\n  </div>\n\n  <div class=\"ol-control m-layer-legend\" *ngIf=\"((legendLayers$ | async)?.length ?? 0) > 0\">\n    <button class=\"m-layer-legend__toggle\" (click)=\"toggleLegendWindow()\">\n      <pry-icon iconSvg=\"legend\" [width]=\"22\" [height]=\"22\"></pry-icon>\n    </button>\n    <ng-container *ngFor=\"let geoLayer of legendLayers$ | async; let index = index\">\n      <div class=\"m-layer-legend__title\" [class.-hidden]=\"!legendTabOpen\">\n        {{ geoLayer.title }}\n        <ng-container *ngIf=\"isLayerRendered(geoLayer)\">\n          <button class=\"m-layer-legend__toggle\" (click)=\"toggleLegend(index)\">\n            <pry-icon\n              [iconSvg]=\"legendTab === index ? 'chevron_top' : 'chevron_bottom'\"\n              [width]=\"22\"\n              [height]=\"22\"\n            ></pry-icon>\n          </button>\n        </ng-container>\n        <ng-container *ngIf=\"!isLayerRendered(geoLayer)\">\n          <pry-icon [iconSvg]=\"'close'\" [width]=\"22\" [height]=\"22\"></pry-icon>\n        </ng-container>\n      </div>\n      <div\n        class=\"m-layer-legend__image\"\n        [class.-hidden]=\"!legendTabOpen || legendTab !== index || !isLayerRendered(geoLayer)\"\n      >\n        <ng-container *ngIf=\"!imageNotProvided[index] && (geoLayer | legendUrl)\">\n          <img\n            [src]=\"geoLayer | legendUrl\"\n            [alt]=\"'@pry.widget.map.legend' | i18n: { layer: geoLayer.title }\"\n            (error)=\"imageNotProvided[index] = true\"\n          />\n        </ng-container>\n        <ng-container *ngIf=\"imageNotProvided[index]\">\n          <p class=\"m-layer-legend__error\">{{ '@pry.widget.map.legendNotProvided' | i18n }}</p>\n        </ng-container>\n      </div>\n    </ng-container>\n  </div>\n\n  <div [style.height.px]=\"height$ | async\" class=\"o-map-wrapper\">\n    <div class=\"o-map\">\n      <div #map id=\"map\"></div>\n    </div>\n  </div>\n\n  <ng-template #infoTooltipAction let-action=\"action\">\n    <div class=\"m-tooltip\" role=\"tooltip\" id=\"infoTooltipAction\" aria-hidden=\"true\">\n      <span class=\"m-tooltip__text\">{{ '@pry.widget.map.' + action | i18n }}</span>\n    </div>\n  </ng-template>\n\n  <ng-template #infoTooltipDown>\n    <div class=\"m-tooltip\" role=\"tooltip\" id=\"infoTooltipDown_widgetMap\" aria-hidden=\"true\">\n      <span class=\"m-tooltip__text\">{{ '@pry.widget.map.export' | i18n }}</span>\n    </div>\n  </ng-template>\n\n  <ng-template #infoTooltipLoad>\n    <div class=\"m-tooltip\" role=\"tooltip\" id=\"infoTooltipLoad_widgetMap\" aria-hidden=\"true\">\n      <span class=\"m-tooltip__text\">{{ '@pry.widget.map.import' | i18n }}</span>\n    </div>\n  </ng-template>\n\n  <div #popup class=\"m-tooltip m-tooltip--popup\" [hidden]=\"true\" role=\"tooltip\">\n    <div #popupContent></div>\n  </div>\n  <div\n    #address\n    class=\"m-tooltip m-tooltip--address tooltip-address\"\n    [style.display]=\"'none'\"\n    (click)=\"hideAddress()\"\n  ></div>\n  <ng-template\n    #exportTypeTemplate\n    class=\"m-context-menu-wrapper\"\n    id=\"export_type\"\n    aria-hidden=\"true\"\n    aria-label=\"TODO-access\"\n    aria-labelledby=\"export_card\"\n  >\n    <div class=\"m-context-menu\">\n      <ul class=\"m-context-menu__list\">\n        <li class=\"m-context-menu__list__item\">\n          <button type=\"button\" class=\"a-btn -link-like\" (click)=\"export('png')\">\n            <span class=\"u-visually-hidden\">{{ '@pry.action.exportAsFormat' | i18n }} </span> PNG\n          </button>\n        </li>\n        <li class=\"m-context-menu__list__item\">\n          <button type=\"button\" class=\"a-btn -link-like\" (click)=\"export('kml')\">\n            <span class=\"u-visually-hidden\">{{ '@pry.action.exportAsFormat' | i18n }} </span> KML\n          </button>\n        </li>\n        <li class=\"m-context-menu__list__item\">\n          <button type=\"button\" class=\"a-btn -link-like\" (click)=\"export('geoJSON')\">\n            <span class=\"u-visually-hidden\">{{ '@pry.action.exportAsFormat' | i18n }} </span> GeoJSON\n          </button>\n        </li>\n      </ul>\n    </div>\n  </ng-template>\n</div>\n", dependencies: [{ kind: "directive", type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i6.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i6.RadioControlValueAccessor, selector: "input[type=radio][formControlName],input[type=radio][formControl],input[type=radio][ngModel]", inputs: ["name", "formControlName", "value"] }, { kind: "directive", type: i6.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i6.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i2.SettingsComponent, selector: "pry-settings", inputs: ["widgetIndex", "isDisable", "headerPresent", "open$", "header"], outputs: ["saveTriggered"] }, { kind: "component", type: i2.PryWidgetHeaderComponent, selector: "pry-widget-header", inputs: ["manifest", "additionalOptions", "headerOptions", "displayCount", "datasourceIds$", "widgetIndex"], outputs: ["manifestModified"] }, { kind: "component", type: i2.PrySelectComponent, selector: "pry-select", inputs: ["labelTranslate", "baseTranslate", "translationFn", "translationFnArgs", "clearable", "multiple", "multipleClearRight", "placeholder", "isForm", "required", "name", "readonly", "items", "itemsAsOption", "bindData", "bindValue", "bindLabel", "bindIcon", "iconSize", "templateLabel", "templateOption", "autocomplete"] }, { kind: "component", type: i2.PryIconComponent, selector: "pry-icon", inputs: ["color", "iconSvg", "animation", "iconImage", "alt", "width", "height", "classes"] }, { kind: "component", type: i7.PryCheckboxComponent, selector: "pry-checkbox", inputs: ["circle"] }, { kind: "directive", type: i2.PryTooltipDirective, selector: "[pryTooltip]", inputs: ["pryTooltip", "styleReversed", "pryTooltipContext", "pryTooltipPosition", "pryTooltipShowDelay"] }, { kind: "component", type: i2.PryRangeComponent, selector: "pry-range", inputs: ["min", "max", "step", "disabled", "labelTranslate"] }, { kind: "component", type: i8.PryWidgetMapCssComponent, selector: "pry-widget-map-css" }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }, { kind: "pipe", type: i2.I18nPipe, name: "i18n" }, { kind: "pipe", type: i9.GeometryFieldsForPipe, name: "geometryFieldsFor" }, { kind: "pipe", type: i10.WidgetMapLegendUrlPipe, name: "legendUrl" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: WidgetMapComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'pry-widget-map', template: "<pry-widget-map-css></pry-widget-map-css>\n<div class=\"o-widget o-widget--map\">\n  <pry-widget-header\n    [datasourceIds$]=\"datasourceIds$\"\n    *ngIf=\"displayHeader$ | async\"\n    [widgetIndex]=\"widgetIndex\"\n    [manifest]=\"manifest\"\n    (manifestModified)=\"manifestModified.emit($event)\"\n    [headerOptions]=\"(displayHeader$ | async) ?? {}\"\n    #header\n  >\n    <pry-settings\n      (saveTriggered)=\"emitManifest()\"\n      [headerPresent]=\"displayHeader$ | async\"\n      [widgetIndex]=\"widgetIndex\"\n      [header]=\"header\"\n      [open$]=\"open$\"\n      class=\"o-settings\"\n    >\n      <div class=\"m-form-label-field\">\n        <label class=\"a-label\" for=\"map_style\">{{ '@pry.widget.map.style' | i18n }}</label>\n        <pry-select\n          (ngModelChange)=\"changeStyle($event)\"\n          [itemsAsOption]=\"true\"\n          [items]=\"styles$ | async\"\n          [ngModel]=\"optionsCopy.style\"\n          bindLabel=\"label\"\n          bindValue=\"identifier\"\n          id=\"map_style\"\n          class=\"a-pry-select\"\n        ></pry-select>\n      </div>\n\n      <pry-checkbox (ngModelChange)=\"changeFit($event)\" [ngModel]=\"optionsCopy.fit ?? false\">\n        {{ '@pry.widget.map.fit' | i18n }}\n      </pry-checkbox>\n\n      <pry-checkbox (ngModelChange)=\"changeAttributions($event)\" [ngModel]=\"optionsCopy.attributions ?? false\">\n        {{ '@pry.widget.map.attributions' | i18n }}\n      </pry-checkbox>\n\n      <fieldset class=\"m-form-radio-group-wrapper\">\n        <legend class=\"a-label\">{{ '@pry.widget.map.tooltip.title' | i18n }}</legend>\n        <div class=\"m-form-radio-group\">\n          <div class=\"m-form-radio-group__item\">\n            <input\n              class=\"a-form-field\"\n              type=\"radio\"\n              id=\"click\"\n              name=\"tooltip\"\n              [ngModel]=\"optionsCopy.tooltipMode\"\n              (ngModelChange)=\"changeTooltipMode('click')\"\n              value=\"click\"\n              [disabled]=\"((geoServerLayerDescriptions$ | async)?.length ?? 0) > 0\"\n            />\n            <label for=\"click\" class=\"a-label\">\n              {{ '@pry.widget.map.tooltip.click' | i18n }}\n            </label>\n          </div>\n          <div class=\"m-form-radio-group__item\">\n            <input\n              class=\"a-form-field\"\n              type=\"radio\"\n              id=\"hover\"\n              name=\"tooltip\"\n              [ngModel]=\"optionsCopy.tooltipMode\"\n              (ngModelChange)=\"changeTooltipMode('hover')\"\n              value=\"hover\"\n              [disabled]=\"((geoServerLayerDescriptions$ | async)?.length ?? 0) > 0\"\n            />\n            <label for=\"hover\" class=\"a-label\">\n              {{ '@pry.widget.map.tooltip.hover' | i18n }}\n            </label>\n          </div>\n        </div>\n      </fieldset>\n\n      <div class=\"o-settings__popup__content__actions -has-separator\">\n        <button type=\"button\" (click)=\"addLayer()\" class=\"a-btn a-btn--icon-text -link-like\">\n          <pry-icon iconSvg=\"library_add\"></pry-icon>\n          {{ '@pry.widget.map.addLayer' | i18n }}\n        </button>\n      </div>\n\n      <div *ngFor=\"let layer of optionsCopy?.layers; let i = index\" class=\"o-settings__popup__content__fields\">\n        <div class=\"o-settings__popup__content__fields__head\">\n          <h3 class=\"a-h3 settings-layer-title__title\">{{ '@pry.widget.map.layer' | i18n: { index: i + 1 } }}</h3>\n          <div class=\"m-btn-group\">\n            <button type=\"button\" class=\"a-btn a-btn--icon-only\" (click)=\"invertLayers(i, i - 1)\" *ngIf=\"i > 0\">\n              <pry-icon iconSvg=\"fleche_haut\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveUp' | i18n }}</span>\n            </button>\n            <button\n              type=\"button\"\n              class=\"a-btn a-btn--icon-only\"\n              (click)=\"invertLayers(i, i + 1)\"\n              *ngIf=\"i < (optionsCopy?.layers?.length ?? 0) - 1\"\n            >\n              <pry-icon iconSvg=\"fleche_bas\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveDown' | i18n }}</span>\n            </button>\n          </div>\n        </div>\n\n        <div class=\"o-settings__popup__content__fields__content\">\n          <pry-range\n            [ngModel]=\"(layer?.opacity ?? 100) + ''\"\n            (ngModelChange)=\"changeOpacity(layer, $event)\"\n            labelTranslate=\"@pry.widget.map.opacity\"\n            min=\"0\"\n            max=\"100\"\n          ></pry-range>\n\n          <fieldset>\n            <legend class=\"u-visually-hidden\">{{ '@pry.widget.map.layerOptions' | i18n: { index: i + 1 } }}</legend>\n            <div class=\"m-form-label-field\">\n              <label class=\"a-label\" for=\"map_layerTitle\">{{ '@pry.widget.map.layerTitle' | i18n }}</label>\n              <input\n                id=\"map_layerTitle\"\n                class=\"a-form-field\"\n                type=\"text\"\n                (input)=\"changeTitle($event, layer)\"\n                [value]=\"layer.title ?? ''\"\n              />\n            </div>\n\n            <div class=\"m-form-label-field\">\n              <label class=\"a-label\" for=\"map_layerType\">{{ '@pry.widget.map.layerType.title' | i18n }}</label>\n              <pry-select\n                (ngModelChange)=\"changeLayerType($event, i)\"\n                [bindData]=\"true\"\n                [itemsAsOption]=\"true\"\n                [items]=\"layerTypes\"\n                [labelTranslate]=\"true\"\n                [ngModel]=\"layer.type\"\n                [disabled]=\"layer.type === 'geoserver'\"\n                baseTranslate=\"@pry.widget.map.layerType.\"\n                class=\"a-pry-select\"\n                id=\"map_layerType\"\n              ></pry-select>\n            </div>\n\n            <div\n              *ngIf=\"\n                layer.type !== 'relation' &&\n                layer.type !== 'wms' &&\n                layer.type !== 'wmts' &&\n                layer.type !== 'geoserver' &&\n                layer.type !== 'featurelayer' &&\n                layer.type !== 'vectortile' &&\n                layer.type !== 'rastertile'\n              \"\n              class=\"m-form-label-field\"\n            >\n              <label class=\"a-label\" for=\"map_classes\">{{ '@pry.widget.map.classes' | i18n }}</label>\n              <pry-select\n                (ngModelChange)=\"changeClasses($event, layer)\"\n                [itemsAsOption]=\"true\"\n                [items]=\"classes$ | async\"\n                [multiple]=\"true\"\n                [ngModel]=\"layer.classes\"\n                bindLabel=\"name\"\n                bindValue=\"id\"\n                class=\"a-pry-select\"\n                id=\"map_classes\"\n              ></pry-select>\n            </div>\n          </fieldset>\n        </div>\n\n        <fieldset\n          *ngIf=\"\n            layer.type !== 'relation' &&\n            layer.type !== 'wms' &&\n            layer.type !== 'wmts' &&\n            layer.type !== 'geoserver' &&\n            layer.type !== 'featurelayer' &&\n            layer.type !== 'vectortile' &&\n            layer.type !== 'rastertile'\n          \"\n        >\n          <legend class=\"u-visually-hidden\">{{ '@pry.widget.map.locationAttr' | i18n }}</legend>\n          <ng-container\n            *ngIf=\"\n              layer\n                | geometryFieldsFor: { resultSet: resultSet$, classes: layer.classes, type: layer.type }\n                | async as fields\n            \"\n          >\n            <div\n              *ngIf=\"\n                ['heatmap', 'bubble', 'marker', 'point', 'line', 'polygon', 'multi-line', 'multi-polygon'].indexOf(\n                  layer.type\n                ) >= 0\n              \"\n            >\n              <div class=\"m-form-label-field\">\n                <label class=\"a-label\" for=\"map_locationAttribute_both\">{{\n                  '@pry.widget.map.locationAttribute.both' | i18n\n                }}</label>\n                <pry-select\n                  (ngModelChange)=\"changeLocationAttributes($event, layer)\"\n                  [itemsAsOption]=\"true\"\n                  [items]=\"fields\"\n                  [ngModel]=\"layer.attribute\"\n                  bindLabel=\"name\"\n                  bindValue=\"name\"\n                  id=\"map_locationAttribute_both\"\n                  class=\"a-pry-select\"\n                ></pry-select>\n              </div>\n            </div>\n\n            <div *ngIf=\"['heatmap', 'bubble'].indexOf(layer.type) >= 0\">\n              <div class=\"m-form-label-field\">\n                <label class=\"a-label\" for=\"map_intensityAttribute\">{{\n                  '@pry.widget.map.intensityAttribute' | i18n\n                }}</label>\n                <pry-select\n                  (ngModelChange)=\"changeIntensityAttributes($event, layer)\"\n                  [itemsAsOption]=\"true\"\n                  [items]=\"fields\"\n                  [ngModel]=\"layerHasIntensity(layer).intensityAttribute\"\n                  bindLabel=\"name\"\n                  bindValue=\"name\"\n                  id=\"map_intensityAttribute\"\n                  class=\"a-pry-select\"\n                ></pry-select>\n              </div>\n            </div>\n          </ng-container>\n        </fieldset>\n\n        <fieldset\n          *ngIf=\"\n            layer.type === 'wms' ||\n            layer.type === 'geoserver' ||\n            layer.type === 'wmts' ||\n            layer.type === 'featurelayer' ||\n            layer.type === 'vectortile' ||\n            layer.type === 'rastertile'\n          \"\n        >\n          <legend class=\"u-visually-hidden\">{{ '@pry.widget.map.tile' | i18n }}</legend>\n          <div class=\"m-form-label-field\">\n            <label class=\"a-label\" for=\"map_wms_url\">{{ '@pry.widget.map.wms.url' | i18n }}</label>\n            <input\n              id=\"map_wms_url\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeUrl($event, layer)\"\n              [disabled]=\"layer.type === 'geoserver'\"\n              [value]=\"layer.url\"\n            />\n          </div>\n\n          <div\n            class=\"m-form-label-field\"\n            *ngIf=\"layer.type === 'wms' || layer.type === 'geoserver' || layer.type === 'wmts'\"\n          >\n            <label class=\"a-label\" for=\"map_wms_paramLayer\">{{ '@pry.widget.map.wms.paramLayer' | i18n }}</label>\n            <input\n              id=\"map_wms_paramLayer\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeParamLayer($event, layer)\"\n              [disabled]=\"layer.type === 'geoserver'\"\n              [value]=\"layer.paramLayer\"\n            />\n          </div>\n\n          <div class=\"m-form-label-field\" *ngIf=\"layer.type === 'wmts'\">\n            <label class=\"a-label\" for=\"map_wms_matrixSet\">{{ '@pry.widget.map.wms.matrixSet' | i18n }}</label>\n            <input\n              id=\"map_wms_matrixSet\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeMatrixSet($event, layer)\"\n              [value]=\"layer.matrixSet\"\n            />\n          </div>\n\n          <div class=\"m-form-label-field\" *ngIf=\"layer.type === 'wmts'\">\n            <label class=\"a-label\" for=\"map_wms_style\">{{ '@pry.widget.map.wms.style' | i18n }}</label>\n            <input\n              id=\"map_wms_style\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeParamStyle($event, layer)\"\n              [value]=\"layer.style\"\n            />\n          </div>\n\n          <div class=\"m-form-label-field\" *ngIf=\"layer.type === 'wms'\">\n            <pry-checkbox (ngModelChange)=\"changeParamTiled($event, layer)\" [ngModel]=\"layer?.paramTiled ?? false\">\n              {{ '@pry.widget.map.wms.paramTiled' | i18n }}\n            </pry-checkbox>\n          </div>\n        </fieldset>\n\n        <fieldset *ngIf=\"layer.type === 'marker'\">\n          <legend class=\"u-visually-hidden\">{{ '@pry.widget.map.clustering' | i18n }}</legend>\n          <div class=\"m-form-label-field\">\n            <pry-checkbox (ngModelChange)=\"changeClustered(layer, $event)\" [ngModel]=\"layer.clustered\">\n              {{ '@pry.widget.map.clustered' | i18n }}\n            </pry-checkbox>\n          </div>\n          <div *ngIf=\"layer.clustered\">\n            <pry-range\n              [ngModel]=\"layer.clustered\"\n              (ngModelChange)=\"changeClusterDistance(layer, $event)\"\n              labelTranslate=\"@pry.widget.map.clusterDistance\"\n              min=\"1\"\n              max=\"500\"\n            ></pry-range>\n          </div>\n        </fieldset>\n\n        <div class=\"m-form-label-field\" *ngIf=\"optionsCopy.attributions\">\n          <label class=\"a-label\" for=\"attribution\">{{ '@pry.widget.map.attribution' | i18n }}</label>\n          <input\n            id=\"attribution\"\n            class=\"a-form-field\"\n            type=\"text\"\n            (input)=\"changeAttribution($event, layer)\"\n            [value]=\"layer.attribution ? layer.attribution : ''\"\n          />\n        </div>\n\n        <button\n          type=\"button\"\n          (click)=\"deleteLayer(i)\"\n          class=\"a-btn a-btn--icon-text -link-like\"\n          *ngIf=\"layer.type !== 'geoserver'\"\n          data-func=\"delete\"\n        >\n          <pry-icon iconSvg=\"delete\" [width]=\"19\" [height]=\"19\"></pry-icon>\n          <span>{{ '@pry.widget.map.deleteLayer' | i18n }}</span>\n        </button>\n      </div>\n    </pry-settings>\n  </pry-widget-header>\n\n  <div class=\"m-btn-group -selection-choice\" [style.transform]=\"bottomLeft$ | async\">\n    <ng-container *ngFor=\"let action of basicActions$ | async\">\n      <button\n        type=\"button\"\n        class=\"a-btn a-btn--icon-only\"\n        (click)=\"selectionInteraction.changeSelection(action)\"\n        [class.-selected]=\"selectionInteraction.selectionType === action\"\n        [pryTooltip]=\"infoTooltipAction\"\n        pryTooltipPosition=\"bottom\"\n        aria-describedby=\"infoTooltipAction\"\n        [pryTooltipContext]=\"{ action: action }\"\n      >\n        <pry-icon [iconSvg]=\"action\"></pry-icon>\n        <span class=\"u-visually-hidden\">{{ '@pry.widget.map.' + action | i18n }}</span>\n      </button>\n    </ng-container>\n\n    <button\n      type=\"button\"\n      class=\"a-btn a-btn--icon-only\"\n      id=\"export_card\"\n      aria-expanded=\"false\"\n      aria-controls=\"export_type\"\n      aria-haspopup=\"menu\"\n      [pryTooltip]=\"infoTooltipDown\"\n      pryTooltipPosition=\"bottom\"\n      aria-describedby=\"infoTooltipDown_widgetMap\"\n      *ngIf=\"(actions$ | async)?.includes('export')\"\n    >\n      <pry-icon iconSvg=\"file_download\" (click)=\"displayExportType($event)\"></pry-icon>\n      <span class=\"u-visually-hidden\">{{ '@pry.widget.map.export' | i18n }}</span>\n    </button>\n\n    <button\n      type=\"button\"\n      class=\"a-btn a-btn--icon-only\"\n      (click)=\"uploader.click()\"\n      [pryTooltip]=\"infoTooltipLoad\"\n      aria-describedby=\"infoTooltipLoad_widgetMap\"\n      pryTooltipPosition=\"bottom\"\n      *ngIf=\"(actions$ | async)?.includes('upload')\"\n    >\n      <pry-icon iconSvg=\"file_upload\"></pry-icon>\n      <span class=\"u-visually-hidden\">{{ '@pry.widget.map.import' | i18n }}</span>\n    </button>\n    <input hidden type=\"file\" #uploader (change)=\"import($event)\" />\n  </div>\n\n  <div class=\"ol-control m-layer-legend\" *ngIf=\"((legendLayers$ | async)?.length ?? 0) > 0\">\n    <button class=\"m-layer-legend__toggle\" (click)=\"toggleLegendWindow()\">\n      <pry-icon iconSvg=\"legend\" [width]=\"22\" [height]=\"22\"></pry-icon>\n    </button>\n    <ng-container *ngFor=\"let geoLayer of legendLayers$ | async; let index = index\">\n      <div class=\"m-layer-legend__title\" [class.-hidden]=\"!legendTabOpen\">\n        {{ geoLayer.title }}\n        <ng-container *ngIf=\"isLayerRendered(geoLayer)\">\n          <button class=\"m-layer-legend__toggle\" (click)=\"toggleLegend(index)\">\n            <pry-icon\n              [iconSvg]=\"legendTab === index ? 'chevron_top' : 'chevron_bottom'\"\n              [width]=\"22\"\n              [height]=\"22\"\n            ></pry-icon>\n          </button>\n        </ng-container>\n        <ng-container *ngIf=\"!isLayerRendered(geoLayer)\">\n          <pry-icon [iconSvg]=\"'close'\" [width]=\"22\" [height]=\"22\"></pry-icon>\n        </ng-container>\n      </div>\n      <div\n        class=\"m-layer-legend__image\"\n        [class.-hidden]=\"!legendTabOpen || legendTab !== index || !isLayerRendered(geoLayer)\"\n      >\n        <ng-container *ngIf=\"!imageNotProvided[index] && (geoLayer | legendUrl)\">\n          <img\n            [src]=\"geoLayer | legendUrl\"\n            [alt]=\"'@pry.widget.map.legend' | i18n: { layer: geoLayer.title }\"\n            (error)=\"imageNotProvided[index] = true\"\n          />\n        </ng-container>\n        <ng-container *ngIf=\"imageNotProvided[index]\">\n          <p class=\"m-layer-legend__error\">{{ '@pry.widget.map.legendNotProvided' | i18n }}</p>\n        </ng-container>\n      </div>\n    </ng-container>\n  </div>\n\n  <div [style.height.px]=\"height$ | async\" class=\"o-map-wrapper\">\n    <div class=\"o-map\">\n      <div #map id=\"map\"></div>\n    </div>\n  </div>\n\n  <ng-template #infoTooltipAction let-action=\"action\">\n    <div class=\"m-tooltip\" role=\"tooltip\" id=\"infoTooltipAction\" aria-hidden=\"true\">\n      <span class=\"m-tooltip__text\">{{ '@pry.widget.map.' + action | i18n }}</span>\n    </div>\n  </ng-template>\n\n  <ng-template #infoTooltipDown>\n    <div class=\"m-tooltip\" role=\"tooltip\" id=\"infoTooltipDown_widgetMap\" aria-hidden=\"true\">\n      <span class=\"m-tooltip__text\">{{ '@pry.widget.map.export' | i18n }}</span>\n    </div>\n  </ng-template>\n\n  <ng-template #infoTooltipLoad>\n    <div class=\"m-tooltip\" role=\"tooltip\" id=\"infoTooltipLoad_widgetMap\" aria-hidden=\"true\">\n      <span class=\"m-tooltip__text\">{{ '@pry.widget.map.import' | i18n }}</span>\n    </div>\n  </ng-template>\n\n  <div #popup class=\"m-tooltip m-tooltip--popup\" [hidden]=\"true\" role=\"tooltip\">\n    <div #popupContent></div>\n  </div>\n  <div\n    #address\n    class=\"m-tooltip m-tooltip--address tooltip-address\"\n    [style.display]=\"'none'\"\n    (click)=\"hideAddress()\"\n  ></div>\n  <ng-template\n    #exportTypeTemplate\n    class=\"m-context-menu-wrapper\"\n    id=\"export_type\"\n    aria-hidden=\"true\"\n    aria-label=\"TODO-access\"\n    aria-labelledby=\"export_card\"\n  >\n    <div class=\"m-context-menu\">\n      <ul class=\"m-context-menu__list\">\n        <li class=\"m-context-menu__list__item\">\n          <button type=\"button\" class=\"a-btn -link-like\" (click)=\"export('png')\">\n            <span class=\"u-visually-hidden\">{{ '@pry.action.exportAsFormat' | i18n }} </span> PNG\n          </button>\n        </li>\n        <li class=\"m-context-menu__list__item\">\n          <button type=\"button\" class=\"a-btn -link-like\" (click)=\"export('kml')\">\n            <span class=\"u-visually-hidden\">{{ '@pry.action.exportAsFormat' | i18n }} </span> KML\n          </button>\n        </li>\n        <li class=\"m-context-menu__list__item\">\n          <button type=\"button\" class=\"a-btn -link-like\" (click)=\"export('geoJSON')\">\n            <span class=\"u-visually-hidden\">{{ '@pry.action.exportAsFormat' | i18n }} </span> GeoJSON\n          </button>\n        </li>\n      </ul>\n    </div>\n  </ng-template>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.PrySnackbarService }, { type: i2.PryI18nService }, { type: i2.TooltipFactoryService }, { type: i2.GeocodingService }, { type: i3.Overlay }, { type: i0.ViewContainerRef }, { type: i2.SymbolService }, { type: i0.Injector }, { type: i4.WidgetMapLayerService }, { type: i0.ElementRef }]; }, propDecorators: { mapRef: [{
+                type: ViewChild,
+                args: ['map']
+            }], popup: [{
+                type: ViewChild,
+                args: ['popup']
+            }], popupContent: [{
+                type: ViewChild,
+                args: ['popupContent', { read: ViewContainerRef }]
+            }], exportTypeTemplate: [{
+                type: ViewChild,
+                args: ['exportTypeTemplate', { read: TemplateRef }]
+            }], address: [{
+                type: ViewChild,
+                args: ['address']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-map.component.js","sourceRoot":"","sources":["../../../../../../../projects/provoly/dashboard/widgets/widget-map/component/widget-map.component.ts","../../../../../../../projects/provoly/dashboard/widgets/widget-map/component/widget-map.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Overlay as cdkOverlay, OverlayConfig, OverlayRef } from '@angular/cdk/overlay';\nimport { TemplatePortal } from '@angular/cdk/portal';\nimport {\n  AfterViewInit,\n  Component,\n  ComponentRef,\n  ElementRef,\n  Injector,\n  TemplateRef,\n  ViewChild,\n  ViewContainerRef\n} from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport {\n  Attribute,\n  BaseTooltipComponent,\n  BaseWidgetMapLayerOptions,\n  Class,\n  ClassSelectors,\n  ConfigActions,\n  ConfigSelectors,\n  ContextMenuActions,\n  DashboardActions,\n  DashboardSelectors,\n  Dataset,\n  DataSourceSelectors,\n  DataWidgetComponent,\n  Field,\n  FieldSelectors,\n  GeocodingService,\n  GeoMetadata,\n  ItemUtils,\n  MapFeatureLayerOptions,\n  MapGeoServerLayerOptions,\n  MapRasterTileLayerOptions,\n  MapVectorTileLayerOptions,\n  MapWidgetBubbleLayerOptions,\n  MapWidgetHeatMapLayerOptions,\n  MapWidgetLayerOptions,\n  MapWidgetMarkerLayerOptions,\n  MapWidgetOptions,\n  MapWMSLayerLayerOptions,\n  MapWMTSLayerLayerOptions,\n  PryI18nService,\n  PrySnackbarService,\n  ResultsetUtils,\n  SymbolService,\n  TooltipFactoryService,\n  TooltipMode,\n  WIDGET_HEADER_HEIGHT,\n  widgetMapConfig\n} from '@provoly/dashboard';\nimport equal from 'fast-deep-equal/es6';\nimport { Feature, Map, MapBrowserEvent, Overlay, View } from 'ol';\nimport LayerSwitcher from 'ol-layerswitcher';\nimport { apply } from 'ol-mapbox-style';\nimport { Attribution, Control, ScaleLine } from 'ol/control';\nimport { boundingExtent, createEmpty } from 'ol/extent';\nimport { Circle, Geometry, Point } from 'ol/geom';\nimport { Tile } from 'ol/layer';\nimport BaseLayer from 'ol/layer/Base';\nimport VectorLayer from 'ol/layer/Vector';\nimport { Pixel } from 'ol/pixel';\nimport { fromLonLat, get as getProjection, toLonLat, transform } from 'ol/proj';\n\nimport { register } from 'ol/proj/proj4';\nimport { TileWMS } from 'ol/source';\nimport VectorSource from 'ol/source/Vector';\nimport { Style } from 'ol/style';\nimport proj4 from 'proj4';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  debounceTime,\n  delay,\n  distinctUntilChanged,\n  filter,\n  from,\n  map,\n  mergeMap,\n  Observable,\n  of,\n  startWith,\n  tap\n} from 'rxjs';\nimport { SelectionInteraction } from '../interaction/selection-interaction.class';\nimport { MapFormatsReader } from '../reader/map-formats-reader.class';\nimport { AddressSearchedEvent, SearchBarControl } from '../search-bar/search-bar.control';\nimport {\n  DEFAULT_MAP_CENTER,\n  DEFAULT_ZOOM_MAX,\n  DEFAULT_ZOOM_MIN,\n  DEFAULT_ZOOM_START,\n  exportMapAsGeoJSON,\n  exportMapAsImage,\n  exportMapAsKML,\n  getLinkFeature,\n  getMapAsPng,\n  populateIntensityAttribute,\n  populateLocationAttribute\n} from '../utils/widget-map.utils';\nimport { WidgetMapLayerService } from './widget-map-layer.service';\n\n@Component({\n  selector: 'pry-widget-map',\n  templateUrl: './widget-map.component.html'\n})\nexport class WidgetMapComponent extends DataWidgetComponent implements AfterViewInit {\n  mapUrl$: Observable<string>;\n  @ViewChild('map') mapRef!: ElementRef;\n  @ViewChild('popup') popup!: ElementRef;\n  @ViewChild('popupContent', { read: ViewContainerRef }) popupContent!: ViewContainerRef;\n  @ViewChild('exportTypeTemplate', { read: TemplateRef }) exportTypeTemplate!: TemplateRef<any>;\n  @ViewChild('address') address!: ElementRef;\n  options$: Observable<MapWidgetOptions>;\n  layerTypes = this.widgetMapLayerService.implementationList.sort((a, b) =>\n    this.translateService\n      .instant('@pry.widget.map.layerType.' + a)\n      .localeCompare(this.translateService.instant('@pry.widget.map.layerType.' + b))\n  );\n  optionsCopy: MapWidgetOptions = {} as MapWidgetOptions;\n  classes$: Observable<Class[]>;\n  fields$: Observable<Field[]>;\n  selectedIds$: Observable<string[]>;\n  bottomLeft$: Observable<string>;\n  layers$!: Observable<BaseLayer[]>;\n  selectionInteraction = new SelectionInteraction();\n  map!: Map;\n  map$!: Observable<Map>;\n  additionalLayers$ = new BehaviorSubject<VectorLayer<VectorSource<Geometry>>[]>([]);\n  private overlayRef?: OverlayRef;\n  searchBarControl?: SearchBarControl;\n  layerSwitchControl?: LayerSwitcher;\n  styles$: Observable<{ identifier: string; label: string }[]>;\n  WIDGET_HEADER_HEIGHT = WIDGET_HEADER_HEIGHT;\n  i = 0;\n  itemStyles$!: Observable<{ [id: string]: { classic: Style; bordered: Style } }>;\n  height$: Observable<number>;\n  actions$ = widgetMapConfig.actions$;\n  private wmsFeatures$: Observable<any[]>;\n  private classicFeatures$: BehaviorSubject<any> = new BehaviorSubject([]);\n  geoServerLayerDescriptions$: Observable<MapGeoServerLayerOptions[]>;\n  legendTabOpen = false;\n  legendTab = 0;\n  legendLayers$!: Observable<(MapGeoServerLayerOptions | MapWMSLayerLayerOptions)[]>;\n  imageNotProvided: boolean[] = [];\n  basicActions$: Observable<('click' | 'lasso' | 'rectangle' | 'zoom' | 'move' | 'export' | 'upload')[]>;\n  zoomAndCenter$ = new BehaviorSubject<{ zoom?: { start: number; min: number; max: number }; center?: number[] }>({});\n\n  constructor(\n    store: Store<any>,\n    private snackBar: PrySnackbarService,\n    private translateService: PryI18nService,\n    private tooltipFactoryService: TooltipFactoryService,\n    private geocodingService: GeocodingService,\n    private overlay: cdkOverlay,\n    private viewContainerRef: ViewContainerRef,\n    private symbolService: SymbolService,\n    private injector: Injector,\n    private widgetMapLayerService: WidgetMapLayerService,\n    el: ElementRef\n  ) {\n    super(store, el);\n\n    this.basicActions$ = this.actions$.pipe(\n      map((actions) => actions.filter((action) => action !== 'export' && action !== 'upload'))\n    );\n\n    this.classes$ = this.store\n      .select(ClassSelectors.classes)\n      .pipe(map((classes) => classes.sort((a, b) => a.name.localeCompare(b.name))));\n    this.fields$ = this.store.select(FieldSelectors.fields);\n    this.styles$ = this.store.select(ConfigSelectors.mapStyles).pipe(\n      map((styles) =>\n        styles.concat({\n          identifier: 'none',\n          label: this.translateService.instant('@pry.widget.map.noStyle')\n        })\n      )\n    );\n    this.selectedIds$ = this.store.select(DashboardSelectors.selectedItemIds);\n\n    this.geoServerLayerDescriptions$ = combineLatest([\n      this.usedDatasources$.pipe(startWith([])),\n      this.store.select(ConfigSelectors.geoServerUrl).pipe(debounceTime(10), startWith(undefined))\n    ]).pipe(\n      map(([dataSources, geoServerUrl]) => {\n        if (!geoServerUrl) return [];\n        return dataSources\n          .filter((ds) => ds.metadata?.find((m) => m.metadataDef.name === GeoMetadata.NAMESPACE) !== undefined)\n          .map((ds) => {\n            ds = ds as unknown as Dataset;\n            const metadatas: { [key: string]: string } = {};\n            ds.metadata?.forEach((m) => (metadatas[m.metadataDef.name] = m.value));\n            return {\n              type: 'geoserver',\n              url: geoServerUrl + '/' + metadatas[GeoMetadata.NAMESPACE] + '/wms?SERVICE=WMS&VERSION=1.3.0',\n              paramLayer: metadatas[GeoMetadata.KEY],\n              paramTiled: true,\n              opacity: parseInt(metadatas[GeoMetadata.OPACITY] ?? 100, 10),\n              title: metadatas[GeoMetadata.NAMESPACE] + ':' + metadatas[GeoMetadata.KEY],\n              oClass: ds.oClass,\n              key: metadatas[GeoMetadata.NAMESPACE] + ':' + metadatas[GeoMetadata.KEY]\n            };\n          })\n          .map((layer) => layer as MapGeoServerLayerOptions);\n      })\n    );\n\n    this.options$ = combineLatest([\n      this.manifest$,\n      this.resultSet$,\n      this.classes$,\n      this.fields$,\n      this.styles$,\n      this.geoServerLayerDescriptions$\n    ]).pipe(\n      map(([manifest, resultSet, classes, fields, mapStyles, geoLayers]) => {\n        // auto determine layers parameters to provide a working view\n        const autoOptions = JSON.parse(JSON.stringify({ relations: true, ...manifest.options })) as MapWidgetOptions;\n        if (!autoOptions.tooltipMode) {\n          autoOptions.tooltipMode = TooltipMode.HOVER;\n        }\n        if (geoLayers.length > 0) {\n          autoOptions.tooltipMode = TooltipMode.CLICK;\n        }\n        autoOptions.layers?.forEach((layer, i) => {\n          populateLocationAttribute(layer, resultSet, classes, fields);\n          populateIntensityAttribute(layer, resultSet, classes, fields);\n          if (autoOptions.attributions) {\n            layer.attribution = layer.attribution ?? '';\n          }\n          if (!layer.title) {\n            this.setDefaultLayerTitle(layer, i);\n          }\n        });\n\n        const actualLayerKeys = (autoOptions.layers ?? [])\n          .map((layer) => (layer as MapGeoServerLayerOptions).key ?? null)\n          .filter((key) => !!key);\n\n        // Get all previous layers, without geoserver layers that are not requested anymore, then add new geoserver layers (potentially with a preconfig from manifest).\n        autoOptions.layers = [\n          ...(autoOptions.layers ?? []).map((layer) => {\n            const geoLayer = geoLayers.find((layer) => layer.key === layer.key) ?? null;\n            return layer.type === 'geoserver'\n              ? geoLayer\n                ? { ...geoLayer, ...layer }\n                : (null as unknown as MapWidgetLayerOptions)\n              : { ...layer };\n          }),\n          ...geoLayers.filter((layer) => !actualLayerKeys.includes(layer.key))\n        ].filter((layer) => !!layer);\n\n        if (\n          !!mapStyles &&\n          mapStyles.length > 0 &&\n          (!autoOptions.style || !mapStyles.map((style) => style.identifier).includes(autoOptions.style))\n        ) {\n          const lightStyles = mapStyles.filter((style) => !(style.identifier ?? '-').includes('dark'));\n          autoOptions.style = lightStyles.length > 0 ? lightStyles[0].identifier : mapStyles[0].identifier;\n        }\n        return autoOptions;\n      })\n    );\n    this.subscriptions.add(\n      this.options$.pipe(filter((opt) => !!opt)).subscribe((options) => {\n        this.optionsCopy = JSON.parse(JSON.stringify(options));\n      })\n    );\n    this.subscriptions.add(\n      this.store\n        .select(DashboardSelectors.address)\n        .pipe(filter((addr) => !!addr && !!addr.pointAddress))\n        .subscribe((addr) => {\n          this.map?.dispatchEvent(\n            new AddressSearchedEvent({\n              type: 'searched-address',\n              latLon: addr.latLon,\n              coordinates: fromLonLat([...addr.latLon].reverse(), this.map.getView().getProjection()),\n              query: addr.latLon,\n              address: addr.pointAddress\n            })\n          );\n        })\n    );\n\n    this.mapUrl$ = this.store.select(ConfigSelectors.mapUrl);\n    this.wmsFeatures$ = this.store.select(DashboardSelectors.wmsFeatures);\n\n    this.bottomLeft$ = combineLatest([this.widgetSize$, this.displayHeader$]).pipe(\n      map(\n        ([size, displayHeader]) =>\n          `translate(10px ,calc(${size.height}px - 100% - 10px - ${\n            displayHeader ? WIDGET_HEADER_HEIGHT + 'px' : '0px'\n          }))`\n      ),\n      delay(10)\n    );\n\n    this.itemStyles$ = combineLatest([this.resultSet$, this.manifest$, this.staticResultSet$]).pipe(\n      mergeMap(([rs, manifest, srs]) => {\n        if ((manifest.datasource === undefined || manifest.datasource.length === 0) && !srs) {\n          return of({});\n        } else {\n          return from(\n            new Promise<{ [id: string]: { classic: Style; bordered: Style } }>((resolve, reject) => {\n              const total = Object.values(rs.items).reduce((p, c) => c.length + p, 0);\n              if (total === 0) resolve({});\n              const result = {} as { [id: string]: { classic: Style; bordered: Style } };\n              Object.values(rs.items).forEach((items) => {\n                items.forEach((item) =>\n                  Promise.all([\n                    this.symbolService.getSymbolAsIconStyle(item),\n                    this.symbolService.getSymbolAsIconStyle(item, '#8cd560')\n                  ]).then(([style, bStyle]) => {\n                    result[item.id] = { classic: style, bordered: bStyle };\n                    if (Object.keys(result).length >= total) {\n                      resolve(result);\n                    }\n                  })\n                );\n              });\n            })\n          );\n        }\n      })\n    );\n\n    this.height$ = combineLatest([this.widgetSize$.pipe(debounceTime(100)), this.displayHeader$]).pipe(\n      map(([size, display]) => (size.height ?? 100) - (display ? WIDGET_HEADER_HEIGHT : 0)),\n      delay(10)\n    );\n  }\n\n  ngAfterViewInit(): void {\n    this.map$ = combineLatest([this.mapUrl$, this.options$, this.itemStyles$, this.widgetSize$]).pipe(\n      debounceTime(300),\n      mergeMap(([mapUrl, options, rs]) => {\n        if (!this.map) {\n          this.map = new Map({ target: this.mapRef.nativeElement });\n        }\n\n        this.map.setTarget(undefined);\n        const rect = this.mapRef.nativeElement.getBoundingClientRect();\n        if (rect.height === 0 || rect.width === 0) {\n          console.warn('Map size problem. Resize map');\n        }\n\n        let mapPromise = new Promise<Map>((resolve) => resolve(this.map));\n        if (options.style !== 'none') {\n          mapPromise = apply(this.map, `${mapUrl}/styles/${options.style}/style.json`) as Promise<Map>;\n        }\n\n        return from(mapPromise).pipe(\n          tap((map) => {\n            this.map.setTarget(this.mapRef.nativeElement);\n            this.map.setView(\n              new View({\n                center: fromLonLat(options.center ?? DEFAULT_MAP_CENTER),\n                maxZoom: options.zoom?.max ?? DEFAULT_ZOOM_MAX,\n                minZoom: options.zoom?.min ?? DEFAULT_ZOOM_MIN,\n                zoom: options.zoom?.start ?? DEFAULT_ZOOM_START\n              })\n            );\n            if (!options.attributions) {\n              this.map.getControls().forEach((control: Control) => {\n                if (control instanceof Attribution) {\n                  this.map.removeControl(control);\n                }\n              });\n            }\n\n            this.map.addInteraction(this.selectionInteraction.init(this.store));\n\n            this.addContextMenuInteraction();\n            this.addDropInteraction();\n            this.addOverlayOnHoverInteraction();\n            this.addSearchBarControl();\n            this.addLayerSwitcher();\n            this.addScaleControl();\n            this.addUpdateZoomAndCenter();\n\n            this.fitMapForObjects(options);\n          })\n        );\n      })\n    );\n\n    this.layers$ = combineLatest([\n      this.resultSet$,\n      this.usedDatasources$,\n      this.options$,\n      this.classes$,\n      this.additionalLayers$,\n      this.itemStyles$,\n      this.store.select(ConfigSelectors.geoServerUrl),\n      this.map$\n    ]).pipe(\n      filter(\n        ([resultSet, dataSources, options, classes, additionalLayers, itemStyles, geoServerUrl, map]) =>\n          !!resultSet && !!options && !!classes && !!map\n      ),\n      map(([resultSet, dataSources, options, classes, additionalLayers, itemStyles, geoServerUrl]) => {\n        let hasRelationLayer = null as unknown as VectorLayer<VectorSource<any>>;\n\n        const layers = (options?.layers || [])\n          .filter(\n            // @ts-ignore\n            (layer) => this.widgetMapLayerService.dontNeedLocation.includes(layer.type) || !!layer.attribute\n          )\n          .filter(\n            // @ts-ignore\n            (layer) => this.widgetMapLayerService.dontNeedIntensity.includes(layer.type) || !!layer.intensityAttribute\n          )\n          .map((layer: MapWidgetLayerOptions, idx) => {\n            const attributesForClass = Object.keys(resultSet.items)\n              .map((classId) => ({\n                classId,\n                ...this.getAttributesForDrawing(classes, classId, layer)\n              }))\n              .reduce(\n                (p, c) => ({\n                  ...p,\n                  [c.classId]: c\n                }),\n                {} as {\n                  [key: string]: {\n                    intensityAttribute: Attribute;\n                    locationAttribute: Attribute;\n                  };\n                }\n              );\n\n            let layerClassesId = classes.map((clazz) => clazz.id);\n            if ('classes' in layer && !!layer.classes && layer.classes.length > 0) {\n              layerClassesId = layer.classes;\n            }\n\n            let range = { min: 0, max: 0 };\n            // @ts-ignore\n            if (!!layer.intensityAttribute) {\n              const values = Object.keys(resultSet.items)\n                .map((classId) =>\n                  resultSet.items[classId].map((item) =>\n                    ItemUtils.getAttributeCalculatedValue(item, attributesForClass[item.oClass].intensityAttribute)\n                  )\n                )\n                .reduce((p, c) => [...p, ...c], [])\n                .filter((value) => !!value && typeof value === 'number') as number[];\n\n              range = values.reduce((p, c) => ({ min: Math.min(p.min, c), max: Math.max(p.max, c) }), {\n                min: Number.MAX_VALUE,\n                max: -Number.MAX_VALUE\n              });\n            }\n\n            const impl = this.widgetMapLayerService.layersImplementation[layer.type];\n            if (!!impl) {\n              const resultLayer = impl(\n                layer as any,\n                attributesForClass,\n                layerClassesId,\n                resultSet,\n                range,\n                itemStyles,\n                this.map\n              );\n              if (layer.type === 'relation') {\n                hasRelationLayer = resultLayer as unknown as VectorLayer<VectorSource>;\n              }\n              resultLayer.set('title', layer.title);\n              return resultLayer;\n            } else {\n              console.error(`Layer type ${layer.type} is unknown`);\n              return null as unknown as BaseLayer;\n            }\n          })\n          .filter((layer) => !!layer);\n\n        if (!!hasRelationLayer) {\n          const features = layers\n            .filter((layer) => !(layer instanceof Tile))\n            .map((layer) =>\n              layer\n                // @ts-ignore\n                .getSource()\n                .getFeatures()\n                .filter((features: Feature<any>) => !!features.get('id') || !!features.get('features'))\n            )\n            .reduce((p, c) => [...p, ...c], []);\n\n          resultSet.relations.forEach((relation) => {\n            const source = features.find((f: Feature<Point | Circle>) => f.get('id') === relation.source);\n            const dest = features.find((f: Feature<Point | Circle>) => f.get('id') === relation.destination);\n            if (!!source && !!dest) {\n              hasRelationLayer.getSource()?.addFeature(getLinkFeature(relation, source, dest));\n            }\n          });\n        }\n        layers.push(...additionalLayers);\n        layers.forEach((layer, index, arr) => layer.set('zIndex', arr.length - index));\n\n        return layers;\n      })\n    );\n\n    this.legendLayers$ = this.options$.pipe(\n      map(\n        (options) =>\n          (options.layers ?? []).filter((layer) => ['geoserver', 'wms'].includes(layer.type)) as (\n            | MapGeoServerLayerOptions\n            | MapWMSLayerLayerOptions\n          )[]\n      ),\n      delay(10)\n    );\n\n    this.subscriptions.add(\n      combineLatest([\n        this.mapUrl$,\n        this.map$,\n        this.layers$,\n        this.options$,\n        this.selectedIds$,\n        this.additionalLayers$\n      ]).subscribe(([mapUrl, map, layers, options, selectedIds]) => {\n        this.map.setLayers(layers);\n        this.map\n          .getAllLayers()\n          .filter((layer) => !(layer instanceof Tile))\n          .forEach((layer) => {\n            (layer.getSource() as VectorSource)?.getFeatures().forEach((feature: any) => {\n              const type = feature.get('type');\n              if (['bubble', 'marker', 'point', 'line', 'polygon', 'multi-line', 'multi-polygon'].includes(type)) {\n                feature.setStyle(\n                  feature.get(selectedIds.includes(feature.get('id')) ? 'selectedStyle' : 'classicStyle')\n                );\n              }\n            });\n          });\n\n        setTimeout(() => {\n          if (options.style !== 'none') {\n            apply(this.map, `${mapUrl}/styles/${options.style}/style.json`).then((map) => {\n              this.map.setTarget(this.mapRef.nativeElement);\n            });\n          }\n          this.fitMapForObjects(options, selectedIds);\n          this.map.updateSize();\n        }, 200);\n      })\n    );\n    this.subscriptions.add(\n      combineLatest([this.wmsFeatures$, this.classicFeatures$]).subscribe(([wmsFeatures, classicFeatures]) => {\n        if (this.map) {\n          const popupOverlay = new Overlay({\n            element: this.popup.nativeElement,\n            offset: [9, 9]\n          });\n          this.map.addOverlay(popupOverlay);\n          this.popupContent.clear();\n          const componentPromises = [] as Promise<ComponentRef<BaseTooltipComponent> | null>[];\n          wmsFeatures.forEach((value) => {\n            componentPromises.push(this.generateTooltip(value));\n          });\n          classicFeatures.forEach((value: any) => {\n            componentPromises.push(this.generateTooltip(value));\n          });\n\n          Promise.all(componentPromises).then((promises) => {\n            const realComponents = promises.filter((component) => !!component);\n            if (realComponents.length <= 0) {\n              this.popup.nativeElement.hidden = true;\n              popupOverlay.setPosition([-9999999999, -9999999999]);\n            } else {\n              this.popup.nativeElement.hidden = false;\n              popupOverlay.setPosition(\n                wmsFeatures.length > 0 ? wmsFeatures[0].coordinates : classicFeatures[0].coordinates\n              );\n            }\n          });\n        }\n      })\n    );\n  }\n\n  override initResultSet$() {\n    return combineLatest([\n      this.store.select(DashboardSelectors.resultSets),\n      this.datasourceIds$,\n      this.staticResultSet$,\n      this.store.select(DataSourceSelectors.datasets)\n    ]).pipe(\n      map(([resultSets, resultSetNamesArray, staticResultSet, definitions]) => {\n        if (!!staticResultSet) {\n          return staticResultSet;\n        }\n        const resultSetArray = resultSetNamesArray\n          .filter((rsName) => {\n            const definition = definitions.find((dsd) => dsd.id === rsName) as Dataset | undefined;\n            return !definition || !(definition.metadata ?? []).find((meta) => meta.metadataDef.name === '_geoKey');\n          })\n          .map((rsName) => resultSets[rsName ?? ''])\n          .filter((rsName) => !!rsName);\n        return resultSetArray.reduce((rs1, rs2) => ResultsetUtils.mergeResultSets(rs1, rs2), {\n          items: {},\n          relations: [],\n          merged: resultSetArray.length\n        });\n      }),\n      distinctUntilChanged((p, v) => equal(p, v))\n    );\n  }\n\n  generateTooltip(value: {\n    oClass: string;\n    coordinates: Pixel;\n    values: any;\n  }): Promise<ComponentRef<BaseTooltipComponent> | null> {\n    return new Promise((resolve) => {\n      const component$ = this.tooltipFactoryService.generateTooltip(value.oClass, this.injector, this.popupContent);\n      component$.subscribe((component) => {\n        if (component) {\n          component.instance.data.item = value.values;\n          component.instance.popup = this.popup;\n          resolve(component);\n        }\n        resolve(null);\n      });\n    });\n  }\n\n  setDefaultLayerTitle(layer: MapWidgetLayerOptions, idx: number) {\n    layer.title = idx + 1 + ' - ' + this.translateService.instant(`@pry.widget.map.layerType.${layer.type}`);\n  }\n\n  fitMapForObjects(options: MapWidgetOptions, selectedIds?: string[]) {\n    if (!!options?.fit) {\n      let extent = createEmpty();\n      const listOfMarkers = [] as any[];\n\n      this.map\n        .getAllLayers()\n        .filter(\n          (layer) => !!layer.getSource && !!layer.getSource() && !!(layer.getSource() as VectorSource).getFeatures\n        )\n        .forEach((layer) => {\n          (layer.getSource() as VectorSource).getFeatures().forEach((feature: any) => {\n            const id = feature.get('id');\n            if (!selectedIds || selectedIds.length <= 0 || (selectedIds.length > 0 && selectedIds.includes(id))) {\n              switch (feature.get('type')) {\n                case 'heatpoint':\n                case 'point':\n                case 'marker':\n                  listOfMarkers.push(feature.getGeometry().getCoordinates());\n                  break;\n                case 'line':\n                case 'link':\n                  listOfMarkers.push(...feature.getGeometry().getCoordinates());\n                  break;\n                case 'polygon':\n                case 'multi-line':\n                  listOfMarkers.push(...feature.getGeometry().getCoordinates().flat());\n                  break;\n                case 'multi-polygon':\n                  listOfMarkers.push(...feature.getGeometry().getCoordinates().flat().flat());\n                  break;\n                default:\n                  listOfMarkers.push(feature.getGeometry().getCenter());\n              }\n            }\n          });\n        });\n\n      const selectedExtent = boundingExtent(listOfMarkers.filter((coord) => !!coord));\n      if (\n        selectedExtent[0] !== Infinity &&\n        selectedExtent[1] !== Infinity &&\n        selectedExtent[2] !== -Infinity &&\n        selectedExtent[3] !== -Infinity\n      ) {\n        extent = selectedExtent;\n      }\n\n      if (extent[0] !== Infinity && extent[1] !== Infinity && extent[2] !== -Infinity && extent[3] !== -Infinity) {\n        this.map.getView().fit(extent, { padding: [20, 20, 70, 70], duration: 200 });\n      }\n    }\n  }\n\n  private addOverlayOnHoverInteraction() {\n    const popupOverlay = new Overlay({\n      element: this.popup.nativeElement,\n      offset: [9, 9]\n    });\n    this.map.addOverlay(popupOverlay);\n    if (this.optionsCopy.tooltipMode !== TooltipMode.NONE) {\n      const tooltip = this.optionsCopy.tooltipMode === TooltipMode.CLICK ? 'singleclick' : 'pointermove';\n      this.map.on(tooltip, (event: MapBrowserEvent<MouseEvent>) => {\n        const values = this.map.getFeaturesAtPixel(event.pixel, { hitTolerance: 5 }) as (\n          | Feature<Circle>\n          | Feature<Point>\n        )[];\n        const valuesToDisplay = [\n          ...new Set(\n            values\n              .map((value) => value.get('id'))\n              .filter((id) => !!id)\n              .map((id) => values.find((value) => value.get('id') === id))\n              .map((value) => ({\n                oClass: value?.get('oClass'),\n                coordinates: event.coordinate,\n                values: value?.getKeys().reduce((p, c) => ({ ...p, [c]: value.get(c) }), {})\n              }))\n          )\n        ];\n        this.classicFeatures$.next(valuesToDisplay);\n        const wmsLayers = this.getWMSLayers();\n        if (wmsLayers) {\n          this.getFeatureFromServer(wmsLayers, event.coordinate);\n        }\n      });\n    }\n  }\n\n  private addContextMenuInteraction() {\n    if (this.manifest.contextMenu !== false) {\n      this.map.getViewport().addEventListener('contextmenu', (e: MouseEvent) => {\n        const mapCoordinates = this.map.getEventPixel(e);\n        const itemId = this.map.forEachFeatureAtPixel(mapCoordinates, (feature: any) => feature.get('id'));\n        this.store.dispatch(\n          ContextMenuActions.open({\n            itemId,\n            clientX: e.clientX,\n            clientY: e.clientY,\n            resultSet: Array.isArray(this.manifest.datasource) ? this.manifest.datasource[0] : this.manifest.datasource,\n            from: 'map',\n            coordinates: toLonLat(\n              this.map.getCoordinateFromPixel(mapCoordinates),\n              this.map.getView().getProjection()\n            ).reverse()\n          })\n        );\n        e.preventDefault();\n      });\n    }\n  }\n\n  private getAttributesForDrawing(classes: Class[], classId: string, layer: MapWidgetLayerOptions) {\n    const classObj = classes.find((cl) => cl.id === classId) ?? ({ attributes: [] as Attribute[] } as Class);\n    const locationAttribute = this.getLocationAttribute(classObj, layer);\n    const intensityAttribute = this.getIntensityAttribute(\n      classObj,\n      layer as MapWidgetHeatMapLayerOptions | MapWidgetBubbleLayerOptions\n    );\n    return { locationAttribute, intensityAttribute };\n  }\n\n  private getIntensityAttribute(\n    classObj: Class | undefined,\n    layer: MapWidgetHeatMapLayerOptions | MapWidgetBubbleLayerOptions\n  ) {\n    return (\n      (classObj || { attributes: [] }).attributes.find((attr) => attr.name === layer?.intensityAttribute ?? '') ??\n      (undefined as unknown as Attribute)\n    );\n  }\n\n  private getLocationAttribute(classObj: Class, layer: MapWidgetLayerOptions): Attribute {\n    type layers = MapWidgetHeatMapLayerOptions | MapWidgetMarkerLayerOptions | MapWidgetBubbleLayerOptions;\n    const specificLayer = layer as layers;\n    return (\n      classObj.attributes.find((attr) => attr.name === (specificLayer?.attribute ?? []) ?? '') ??\n      (undefined as unknown as Attribute)\n    );\n  }\n\n  changeStyle($event: any) {\n    this.optionsCopy.style = $event;\n  }\n\n  changeFit($event: boolean) {\n    this.optionsCopy.fit = $event;\n  }\n\n  changeAttributions($event: boolean) {\n    this.optionsCopy.attributions = $event;\n    if (this.optionsCopy.attributions) {\n      this.optionsCopy.layers?.forEach((layer) => (layer.attribution = ''));\n    } else {\n      this.optionsCopy.layers?.forEach((layer) => delete layer.attribution);\n    }\n  }\n\n  changeTooltipMode($event: 'hover' | 'click') {\n    this.optionsCopy.tooltipMode = $event === 'hover' ? TooltipMode.HOVER : TooltipMode.CLICK;\n  }\n\n  addLayer() {\n    if (!this.optionsCopy.layers) {\n      this.optionsCopy.layers = [];\n    }\n    this.optionsCopy.layers.push({ attribute: '' } as MapWidgetLayerOptions);\n  }\n\n  changeLayerType($event: any, i: number) {\n    if (!this.optionsCopy.layers) {\n      this.optionsCopy.layers = this.optionsCopy.layers ?? [];\n    }\n    this.optionsCopy.layers[i].type = $event;\n    if (this.optionsCopy.layers[i].type === 'wms') {\n      const options = this.optionsCopy.layers[i] as MapWMSLayerLayerOptions;\n      options.paramLayer = options.paramLayer ?? '';\n      options.url = options.url ?? '';\n    }\n    if (this.optionsCopy.layers[i].type === 'wmts') {\n      const options = this.optionsCopy.layers[i] as MapWMTSLayerLayerOptions;\n      options.paramLayer = options.paramLayer ?? '';\n      options.style = options.style ?? '';\n      options.matrixSet = options.matrixSet ?? '';\n      options.url = options.url ?? '';\n    }\n    if (['featurelayer', 'vectortile', 'rastertile'].includes(this.optionsCopy.layers[i].type)) {\n      const options = this.optionsCopy.layers[i] as MapFeatureLayerOptions;\n      options.url = options.url ?? '';\n    }\n  }\n\n  changeTitle($event: any, layer: MapWidgetLayerOptions) {\n    layer.title = $event.currentTarget?.value;\n  }\n\n  emitManifest() {\n    this.manifestModified.emit({\n      widgetIndex: this.widgetIndex,\n      manifest: {\n        ...this.manifest,\n        options: { ...this.optionsCopy, layers: (this.optionsCopy.layers ?? []).filter((layer) => !!layer.type) }\n      }\n    });\n  }\n\n  changeLocationAttributes($event: any, layer: MapWidgetLayerOptions) {\n    // @ts-ignore\n    layer.attribute = $event;\n  }\n\n  layerHasIntensity(layer: MapWidgetLayerOptions): MapWidgetHeatMapLayerOptions | MapWidgetBubbleLayerOptions {\n    return <MapWidgetHeatMapLayerOptions | MapWidgetBubbleLayerOptions>layer;\n  }\n\n  changeIntensityAttributes($event: any, layer: MapWidgetLayerOptions) {\n    const layer_ = <MapWidgetHeatMapLayerOptions | MapWidgetBubbleLayerOptions>layer;\n    layer_.intensityAttribute = $event;\n  }\n\n  changeClasses($event: string[], layer: MapWidgetLayerOptions) {\n    const specificLayer = layer as\n      | MapWidgetHeatMapLayerOptions\n      | MapWidgetMarkerLayerOptions\n      | MapWidgetBubbleLayerOptions;\n    specificLayer.classes = $event;\n  }\n\n  deleteLayer(i: number) {\n    this.optionsCopy?.layers?.splice(i, 1);\n  }\n\n  invertLayers(idx: number, idxWith: number) {\n    if (!!this.optionsCopy && !!this.optionsCopy.layers) {\n      const tmp = this.optionsCopy.layers[idxWith];\n      this.optionsCopy.layers[idxWith] = this.optionsCopy.layers[idx];\n      this.optionsCopy.layers[idx] = tmp;\n    }\n  }\n\n  changeUrl(\n    $event: Event,\n    layer:\n      | MapWMSLayerLayerOptions\n      | MapFeatureLayerOptions\n      | MapVectorTileLayerOptions\n      | MapRasterTileLayerOptions\n      | MapWMTSLayerLayerOptions\n      | MapGeoServerLayerOptions\n  ) {\n    // @ts-ignore\n    layer.url = $event.currentTarget?.value;\n  }\n\n  changeAttribution($event: Event, layer: BaseWidgetMapLayerOptions) {\n    // @ts-ignore\n    layer.attribution = $event.currentTarget?.value;\n  }\n\n  changeParamLayer(\n    $event: Event,\n    layer: MapWMSLayerLayerOptions | MapWMTSLayerLayerOptions | MapGeoServerLayerOptions\n  ) {\n    // @ts-ignore\n    layer.paramLayer = $event.currentTarget?.value;\n  }\n\n  changeParamTiled($event: boolean, layer: MapWMSLayerLayerOptions) {\n    layer.paramTiled = $event;\n  }\n\n  changeMatrixSet($event: Event, layer: MapWMTSLayerLayerOptions) {\n    // @ts-ignore\n    layer.matrixSet = $event.currentTarget?.value;\n  }\n\n  changeParamStyle($event: Event, layer: MapWMTSLayerLayerOptions) {\n    // @ts-ignore\n    layer.style = $event.currentTarget?.value;\n  }\n\n  export(type: string) {\n    switch (type) {\n      case 'png':\n        exportMapAsImage(this.map, 'map.png');\n        break;\n      case 'kml':\n        exportMapAsKML(this.map, 'map.kml');\n        break;\n      case 'geoJSON':\n        exportMapAsGeoJSON(this.map, 'map.geojson');\n        break;\n      default:\n        console.error('Unknown format');\n    }\n    this.hideExportType();\n  }\n\n  override toImage(): Promise<string> {\n    return getMapAsPng(this.map);\n  }\n\n  import(event: Event | DragEvent) {\n    const reader = new MapFormatsReader(this.map);\n    const input = event instanceof DragEvent ? event.dataTransfer : (event.target as HTMLInputElement);\n    if (!!input && !!input.files && input.files.length > 0) {\n      const filename = input.files[0].name;\n      this.snackBar.open({\n        type: 'info',\n        message: this.translateService.instant('@pry.widget.map.importStart', { filename })\n      });\n      reader\n        .decodeFile(input.files[0])\n        .then((layer) => {\n          this.additionalLayers$.next([...this.additionalLayers$.getValue(), layer]);\n          this.snackBar.open({\n            type: 'success',\n            message: this.translateService.instant('@pry.widget.map.importOk', { filename })\n          });\n        })\n        .catch((err) =>\n          this.snackBar.open({ type: 'error', message: this.translateService.instant(err.msg, err.val) })\n        );\n    }\n    if (!!input && !(input instanceof DataTransfer)) {\n      input.value = null as unknown as string;\n    }\n  }\n\n  private addDropInteraction() {\n    this.map.getViewport().addEventListener('drop', (e: DragEvent) => {\n      this.import(e);\n      e.preventDefault();\n    });\n  }\n\n  changeClustered(layer: MapWidgetMarkerLayerOptions, $event: boolean) {\n    layer.clustered = $event;\n    if (layer.clustered) {\n      layer.clusterDistance = 10;\n    }\n  }\n\n  changeClusterDistance(layer: MapWidgetMarkerLayerOptions, $event: Event) {\n    // @ts-ignore\n    layer.clusterDistance = $event.currentTarget?.value;\n  }\n\n  private addScaleControl() {\n    this.map.addControl(\n      new ScaleLine({\n        units: 'metric',\n        bar: true,\n        steps: 4,\n        text: true,\n        minWidth: 140\n      })\n    );\n  }\n\n  private addSearchBarControl() {\n    this.searchBarControl = new SearchBarControl({}).withGeocodingService(this.geocodingService);\n    this.map.addControl(this.searchBarControl);\n\n    const addressOverlay = new Overlay({\n      element: this.address.nativeElement,\n      offset: [9, 9]\n    });\n    this.map.addOverlay(addressOverlay);\n\n    // @ts-ignore\n    this.map.on('searched-address', (evt: AddressSearchedEvent) => {\n      this.address.nativeElement.innerHTML = `<div>\n        <div>${this.translateService.instant('@pry.widget.map.address')}: ${evt.address}</div>\n        <div>${this.translateService.instant('@pry.widget.map.addressCoords')}: ${evt.latLon}</div>\n        </div>`;\n      this.address.nativeElement.style.display = '';\n      addressOverlay.setPosition(evt.coordinates);\n      this.map.getView().setCenter(evt.coordinates);\n      this.map.getView().setZoom(this.map.getView().getMaxZoom());\n    });\n  }\n\n  private addLayerSwitcher() {\n    this.layerSwitchControl = new LayerSwitcher({\n      activationMode: 'click',\n      reverse: false\n    });\n    this.map.addControl(this.layerSwitchControl);\n\n    // @ts-ignore\n    this.layerSwitchControl.on('show', () => {\n      this.legendTabOpen = false;\n    });\n  }\n\n  hideAddress() {\n    this.address.nativeElement.style.display = 'none';\n  }\n\n  private addUpdateZoomAndCenter() {\n    this.map.on('moveend', () => {\n      this.optionsCopy.zoom = {\n        start: this.map.getView().getZoom() ?? this.optionsCopy.zoom?.start ?? this.map.getView().getMinZoom(),\n        min: this.map.getView().getMinZoom(),\n        max: this.map.getView().getMaxZoom()\n      };\n      this.optionsCopy.center = toLonLat(this.map.getView().getCenter() ?? [0, 0]) ?? this.optionsCopy.center;\n      this.zoomAndCenter$.next({ zoom: this.optionsCopy.zoom, center: this.optionsCopy.center });\n    });\n  }\n\n  changeOpacity(layer: MapWidgetLayerOptions, $event: string) {\n    // @ts-ignore\n    layer.opacity = parseInt($event, 10);\n  }\n\n  displayExportType($event: MouseEvent) {\n    this.overlayRef = this.overlay.create(\n      new OverlayConfig({\n        hasBackdrop: true,\n        panelClass: ['m-context-menu-wrapper'],\n        backdropClass: 'backdrop'\n      })\n    );\n    this.store.dispatch(ConfigActions.addingOverlay({ id: this.constructor.name }));\n    this.overlayRef.backdropClick().subscribe((_) => this.hideExportType());\n    this.overlayRef.attach(new TemplatePortal(this.exportTypeTemplate, this.viewContainerRef));\n\n    const contextMenu = document.querySelector('div.m-context-menu-wrapper') as HTMLDivElement;\n    if (!!contextMenu) {\n      contextMenu.style.left = $event.clientX - 10 + 'px';\n      contextMenu.style.top = $event.clientY - 10 - contextMenu.clientHeight + 'px';\n    }\n  }\n\n  hideExportType() {\n    this.overlayRef?.dispose();\n    this.store.dispatch(ConfigActions.addingOverlay({ id: this.constructor.name }));\n  }\n\n  getWMSLayers() {\n    return !this.map\n      ? []\n      : this.map\n          .getAllLayers()\n          .filter((layer) => layer.getSource() instanceof TileWMS)\n          // @ts-ignore\n          .filter((layer) => layer.rendered === true);\n  }\n\n  isLayerRendered(layer: any) {\n    return !!this.getWMSLayers().find((wmsLayer) => wmsLayer.get('title') === layer.title);\n  }\n\n  private getFeatureFromServer(wmsLayers: any[], pixel: Pixel) {\n    proj4.defs(\n      'EPSG:2154',\n      '+proj=lcc +lat_0=46.5 +lon_0=3 +lat_1=49 +lat_2=44 +x_0=700000 +y_0=6600000 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs +type=crs'\n    );\n    register(proj4);\n    const projGeo = getProjection('EPSG:3857');\n    const projLambert = getProjection('EPSG:2154');\n\n    if (projLambert && projGeo) {\n      for (const layer of wmsLayers) {\n        const url = layer\n          .getSource()\n          .getFeatureInfoUrl(transform(pixel, projGeo, projLambert), this.map.getView().getResolution(), 'EPSG:2154', {\n            INFO_FORMAT: 'application/json',\n            FEATURE_COUNT: 10\n          });\n        if (url) {\n          this.store.dispatch(\n            DashboardActions.getWmsFeatures({\n              url,\n              oClass: layer.getProperties().oClass ?? '',\n              coordinates: pixel\n            })\n          );\n        }\n      }\n    }\n  }\n\n  changeWmsClass($event: any, layer: MapWMSLayerLayerOptions) {\n    layer.oClass = $event;\n  }\n\n  toggleLegend(index: number) {\n    this.legendTab = this.legendTab === index ? -1 : index;\n  }\n\n  toggleLegendWindow() {\n    this.legendTabOpen = !this.legendTabOpen;\n    this.layerSwitchControl?.hidePanel();\n  }\n}\n","<pry-widget-map-css></pry-widget-map-css>\n<div class=\"o-widget o-widget--map\">\n  <pry-widget-header\n    [datasourceIds$]=\"datasourceIds$\"\n    *ngIf=\"displayHeader$ | async\"\n    [widgetIndex]=\"widgetIndex\"\n    [manifest]=\"manifest\"\n    (manifestModified)=\"manifestModified.emit($event)\"\n    [headerOptions]=\"(displayHeader$ | async) ?? {}\"\n    #header\n  >\n    <pry-settings\n      (saveTriggered)=\"emitManifest()\"\n      [headerPresent]=\"displayHeader$ | async\"\n      [widgetIndex]=\"widgetIndex\"\n      [header]=\"header\"\n      [open$]=\"open$\"\n      class=\"o-settings\"\n    >\n      <div class=\"m-form-label-field\">\n        <label class=\"a-label\" for=\"map_style\">{{ '@pry.widget.map.style' | i18n }}</label>\n        <pry-select\n          (ngModelChange)=\"changeStyle($event)\"\n          [itemsAsOption]=\"true\"\n          [items]=\"styles$ | async\"\n          [ngModel]=\"optionsCopy.style\"\n          bindLabel=\"label\"\n          bindValue=\"identifier\"\n          id=\"map_style\"\n          class=\"a-pry-select\"\n        ></pry-select>\n      </div>\n\n      <pry-checkbox (ngModelChange)=\"changeFit($event)\" [ngModel]=\"optionsCopy.fit ?? false\">\n        {{ '@pry.widget.map.fit' | i18n }}\n      </pry-checkbox>\n\n      <pry-checkbox (ngModelChange)=\"changeAttributions($event)\" [ngModel]=\"optionsCopy.attributions ?? false\">\n        {{ '@pry.widget.map.attributions' | i18n }}\n      </pry-checkbox>\n\n      <fieldset class=\"m-form-radio-group-wrapper\">\n        <legend class=\"a-label\">{{ '@pry.widget.map.tooltip.title' | i18n }}</legend>\n        <div class=\"m-form-radio-group\">\n          <div class=\"m-form-radio-group__item\">\n            <input\n              class=\"a-form-field\"\n              type=\"radio\"\n              id=\"click\"\n              name=\"tooltip\"\n              [ngModel]=\"optionsCopy.tooltipMode\"\n              (ngModelChange)=\"changeTooltipMode('click')\"\n              value=\"click\"\n              [disabled]=\"((geoServerLayerDescriptions$ | async)?.length ?? 0) > 0\"\n            />\n            <label for=\"click\" class=\"a-label\">\n              {{ '@pry.widget.map.tooltip.click' | i18n }}\n            </label>\n          </div>\n          <div class=\"m-form-radio-group__item\">\n            <input\n              class=\"a-form-field\"\n              type=\"radio\"\n              id=\"hover\"\n              name=\"tooltip\"\n              [ngModel]=\"optionsCopy.tooltipMode\"\n              (ngModelChange)=\"changeTooltipMode('hover')\"\n              value=\"hover\"\n              [disabled]=\"((geoServerLayerDescriptions$ | async)?.length ?? 0) > 0\"\n            />\n            <label for=\"hover\" class=\"a-label\">\n              {{ '@pry.widget.map.tooltip.hover' | i18n }}\n            </label>\n          </div>\n        </div>\n      </fieldset>\n\n      <div class=\"o-settings__popup__content__actions -has-separator\">\n        <button type=\"button\" (click)=\"addLayer()\" class=\"a-btn a-btn--icon-text -link-like\">\n          <pry-icon iconSvg=\"library_add\"></pry-icon>\n          {{ '@pry.widget.map.addLayer' | i18n }}\n        </button>\n      </div>\n\n      <div *ngFor=\"let layer of optionsCopy?.layers; let i = index\" class=\"o-settings__popup__content__fields\">\n        <div class=\"o-settings__popup__content__fields__head\">\n          <h3 class=\"a-h3 settings-layer-title__title\">{{ '@pry.widget.map.layer' | i18n: { index: i + 1 } }}</h3>\n          <div class=\"m-btn-group\">\n            <button type=\"button\" class=\"a-btn a-btn--icon-only\" (click)=\"invertLayers(i, i - 1)\" *ngIf=\"i > 0\">\n              <pry-icon iconSvg=\"fleche_haut\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveUp' | i18n }}</span>\n            </button>\n            <button\n              type=\"button\"\n              class=\"a-btn a-btn--icon-only\"\n              (click)=\"invertLayers(i, i + 1)\"\n              *ngIf=\"i < (optionsCopy?.layers?.length ?? 0) - 1\"\n            >\n              <pry-icon iconSvg=\"fleche_bas\"></pry-icon>\n              <span class=\"u-visually-hidden\">{{ '@pry.action.moveDown' | i18n }}</span>\n            </button>\n          </div>\n        </div>\n\n        <div class=\"o-settings__popup__content__fields__content\">\n          <pry-range\n            [ngModel]=\"(layer?.opacity ?? 100) + ''\"\n            (ngModelChange)=\"changeOpacity(layer, $event)\"\n            labelTranslate=\"@pry.widget.map.opacity\"\n            min=\"0\"\n            max=\"100\"\n          ></pry-range>\n\n          <fieldset>\n            <legend class=\"u-visually-hidden\">{{ '@pry.widget.map.layerOptions' | i18n: { index: i + 1 } }}</legend>\n            <div class=\"m-form-label-field\">\n              <label class=\"a-label\" for=\"map_layerTitle\">{{ '@pry.widget.map.layerTitle' | i18n }}</label>\n              <input\n                id=\"map_layerTitle\"\n                class=\"a-form-field\"\n                type=\"text\"\n                (input)=\"changeTitle($event, layer)\"\n                [value]=\"layer.title ?? ''\"\n              />\n            </div>\n\n            <div class=\"m-form-label-field\">\n              <label class=\"a-label\" for=\"map_layerType\">{{ '@pry.widget.map.layerType.title' | i18n }}</label>\n              <pry-select\n                (ngModelChange)=\"changeLayerType($event, i)\"\n                [bindData]=\"true\"\n                [itemsAsOption]=\"true\"\n                [items]=\"layerTypes\"\n                [labelTranslate]=\"true\"\n                [ngModel]=\"layer.type\"\n                [disabled]=\"layer.type === 'geoserver'\"\n                baseTranslate=\"@pry.widget.map.layerType.\"\n                class=\"a-pry-select\"\n                id=\"map_layerType\"\n              ></pry-select>\n            </div>\n\n            <div\n              *ngIf=\"\n                layer.type !== 'relation' &&\n                layer.type !== 'wms' &&\n                layer.type !== 'wmts' &&\n                layer.type !== 'geoserver' &&\n                layer.type !== 'featurelayer' &&\n                layer.type !== 'vectortile' &&\n                layer.type !== 'rastertile'\n              \"\n              class=\"m-form-label-field\"\n            >\n              <label class=\"a-label\" for=\"map_classes\">{{ '@pry.widget.map.classes' | i18n }}</label>\n              <pry-select\n                (ngModelChange)=\"changeClasses($event, layer)\"\n                [itemsAsOption]=\"true\"\n                [items]=\"classes$ | async\"\n                [multiple]=\"true\"\n                [ngModel]=\"layer.classes\"\n                bindLabel=\"name\"\n                bindValue=\"id\"\n                class=\"a-pry-select\"\n                id=\"map_classes\"\n              ></pry-select>\n            </div>\n          </fieldset>\n        </div>\n\n        <fieldset\n          *ngIf=\"\n            layer.type !== 'relation' &&\n            layer.type !== 'wms' &&\n            layer.type !== 'wmts' &&\n            layer.type !== 'geoserver' &&\n            layer.type !== 'featurelayer' &&\n            layer.type !== 'vectortile' &&\n            layer.type !== 'rastertile'\n          \"\n        >\n          <legend class=\"u-visually-hidden\">{{ '@pry.widget.map.locationAttr' | i18n }}</legend>\n          <ng-container\n            *ngIf=\"\n              layer\n                | geometryFieldsFor: { resultSet: resultSet$, classes: layer.classes, type: layer.type }\n                | async as fields\n            \"\n          >\n            <div\n              *ngIf=\"\n                ['heatmap', 'bubble', 'marker', 'point', 'line', 'polygon', 'multi-line', 'multi-polygon'].indexOf(\n                  layer.type\n                ) >= 0\n              \"\n            >\n              <div class=\"m-form-label-field\">\n                <label class=\"a-label\" for=\"map_locationAttribute_both\">{{\n                  '@pry.widget.map.locationAttribute.both' | i18n\n                }}</label>\n                <pry-select\n                  (ngModelChange)=\"changeLocationAttributes($event, layer)\"\n                  [itemsAsOption]=\"true\"\n                  [items]=\"fields\"\n                  [ngModel]=\"layer.attribute\"\n                  bindLabel=\"name\"\n                  bindValue=\"name\"\n                  id=\"map_locationAttribute_both\"\n                  class=\"a-pry-select\"\n                ></pry-select>\n              </div>\n            </div>\n\n            <div *ngIf=\"['heatmap', 'bubble'].indexOf(layer.type) >= 0\">\n              <div class=\"m-form-label-field\">\n                <label class=\"a-label\" for=\"map_intensityAttribute\">{{\n                  '@pry.widget.map.intensityAttribute' | i18n\n                }}</label>\n                <pry-select\n                  (ngModelChange)=\"changeIntensityAttributes($event, layer)\"\n                  [itemsAsOption]=\"true\"\n                  [items]=\"fields\"\n                  [ngModel]=\"layerHasIntensity(layer).intensityAttribute\"\n                  bindLabel=\"name\"\n                  bindValue=\"name\"\n                  id=\"map_intensityAttribute\"\n                  class=\"a-pry-select\"\n                ></pry-select>\n              </div>\n            </div>\n          </ng-container>\n        </fieldset>\n\n        <fieldset\n          *ngIf=\"\n            layer.type === 'wms' ||\n            layer.type === 'geoserver' ||\n            layer.type === 'wmts' ||\n            layer.type === 'featurelayer' ||\n            layer.type === 'vectortile' ||\n            layer.type === 'rastertile'\n          \"\n        >\n          <legend class=\"u-visually-hidden\">{{ '@pry.widget.map.tile' | i18n }}</legend>\n          <div class=\"m-form-label-field\">\n            <label class=\"a-label\" for=\"map_wms_url\">{{ '@pry.widget.map.wms.url' | i18n }}</label>\n            <input\n              id=\"map_wms_url\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeUrl($event, layer)\"\n              [disabled]=\"layer.type === 'geoserver'\"\n              [value]=\"layer.url\"\n            />\n          </div>\n\n          <div\n            class=\"m-form-label-field\"\n            *ngIf=\"layer.type === 'wms' || layer.type === 'geoserver' || layer.type === 'wmts'\"\n          >\n            <label class=\"a-label\" for=\"map_wms_paramLayer\">{{ '@pry.widget.map.wms.paramLayer' | i18n }}</label>\n            <input\n              id=\"map_wms_paramLayer\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeParamLayer($event, layer)\"\n              [disabled]=\"layer.type === 'geoserver'\"\n              [value]=\"layer.paramLayer\"\n            />\n          </div>\n\n          <div class=\"m-form-label-field\" *ngIf=\"layer.type === 'wmts'\">\n            <label class=\"a-label\" for=\"map_wms_matrixSet\">{{ '@pry.widget.map.wms.matrixSet' | i18n }}</label>\n            <input\n              id=\"map_wms_matrixSet\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeMatrixSet($event, layer)\"\n              [value]=\"layer.matrixSet\"\n            />\n          </div>\n\n          <div class=\"m-form-label-field\" *ngIf=\"layer.type === 'wmts'\">\n            <label class=\"a-label\" for=\"map_wms_style\">{{ '@pry.widget.map.wms.style' | i18n }}</label>\n            <input\n              id=\"map_wms_style\"\n              class=\"a-form-field\"\n              type=\"text\"\n              (input)=\"changeParamStyle($event, layer)\"\n              [value]=\"layer.style\"\n            />\n          </div>\n\n          <div class=\"m-form-label-field\" *ngIf=\"layer.type === 'wms'\">\n            <pry-checkbox (ngModelChange)=\"changeParamTiled($event, layer)\" [ngModel]=\"layer?.paramTiled ?? false\">\n              {{ '@pry.widget.map.wms.paramTiled' | i18n }}\n            </pry-checkbox>\n          </div>\n        </fieldset>\n\n        <fieldset *ngIf=\"layer.type === 'marker'\">\n          <legend class=\"u-visually-hidden\">{{ '@pry.widget.map.clustering' | i18n }}</legend>\n          <div class=\"m-form-label-field\">\n            <pry-checkbox (ngModelChange)=\"changeClustered(layer, $event)\" [ngModel]=\"layer.clustered\">\n              {{ '@pry.widget.map.clustered' | i18n }}\n            </pry-checkbox>\n          </div>\n          <div *ngIf=\"layer.clustered\">\n            <pry-range\n              [ngModel]=\"layer.clustered\"\n              (ngModelChange)=\"changeClusterDistance(layer, $event)\"\n              labelTranslate=\"@pry.widget.map.clusterDistance\"\n              min=\"1\"\n              max=\"500\"\n            ></pry-range>\n          </div>\n        </fieldset>\n\n        <div class=\"m-form-label-field\" *ngIf=\"optionsCopy.attributions\">\n          <label class=\"a-label\" for=\"attribution\">{{ '@pry.widget.map.attribution' | i18n }}</label>\n          <input\n            id=\"attribution\"\n            class=\"a-form-field\"\n            type=\"text\"\n            (input)=\"changeAttribution($event, layer)\"\n            [value]=\"layer.attribution ? layer.attribution : ''\"\n          />\n        </div>\n\n        <button\n          type=\"button\"\n          (click)=\"deleteLayer(i)\"\n          class=\"a-btn a-btn--icon-text -link-like\"\n          *ngIf=\"layer.type !== 'geoserver'\"\n          data-func=\"delete\"\n        >\n          <pry-icon iconSvg=\"delete\" [width]=\"19\" [height]=\"19\"></pry-icon>\n          <span>{{ '@pry.widget.map.deleteLayer' | i18n }}</span>\n        </button>\n      </div>\n    </pry-settings>\n  </pry-widget-header>\n\n  <div class=\"m-btn-group -selection-choice\" [style.transform]=\"bottomLeft$ | async\">\n    <ng-container *ngFor=\"let action of basicActions$ | async\">\n      <button\n        type=\"button\"\n        class=\"a-btn a-btn--icon-only\"\n        (click)=\"selectionInteraction.changeSelection(action)\"\n        [class.-selected]=\"selectionInteraction.selectionType === action\"\n        [pryTooltip]=\"infoTooltipAction\"\n        pryTooltipPosition=\"bottom\"\n        aria-describedby=\"infoTooltipAction\"\n        [pryTooltipContext]=\"{ action: action }\"\n      >\n        <pry-icon [iconSvg]=\"action\"></pry-icon>\n        <span class=\"u-visually-hidden\">{{ '@pry.widget.map.' + action | i18n }}</span>\n      </button>\n    </ng-container>\n\n    <button\n      type=\"button\"\n      class=\"a-btn a-btn--icon-only\"\n      id=\"export_card\"\n      aria-expanded=\"false\"\n      aria-controls=\"export_type\"\n      aria-haspopup=\"menu\"\n      [pryTooltip]=\"infoTooltipDown\"\n      pryTooltipPosition=\"bottom\"\n      aria-describedby=\"infoTooltipDown_widgetMap\"\n      *ngIf=\"(actions$ | async)?.includes('export')\"\n    >\n      <pry-icon iconSvg=\"file_download\" (click)=\"displayExportType($event)\"></pry-icon>\n      <span class=\"u-visually-hidden\">{{ '@pry.widget.map.export' | i18n }}</span>\n    </button>\n\n    <button\n      type=\"button\"\n      class=\"a-btn a-btn--icon-only\"\n      (click)=\"uploader.click()\"\n      [pryTooltip]=\"infoTooltipLoad\"\n      aria-describedby=\"infoTooltipLoad_widgetMap\"\n      pryTooltipPosition=\"bottom\"\n      *ngIf=\"(actions$ | async)?.includes('upload')\"\n    >\n      <pry-icon iconSvg=\"file_upload\"></pry-icon>\n      <span class=\"u-visually-hidden\">{{ '@pry.widget.map.import' | i18n }}</span>\n    </button>\n    <input hidden type=\"file\" #uploader (change)=\"import($event)\" />\n  </div>\n\n  <div class=\"ol-control m-layer-legend\" *ngIf=\"((legendLayers$ | async)?.length ?? 0) > 0\">\n    <button class=\"m-layer-legend__toggle\" (click)=\"toggleLegendWindow()\">\n      <pry-icon iconSvg=\"legend\" [width]=\"22\" [height]=\"22\"></pry-icon>\n    </button>\n    <ng-container *ngFor=\"let geoLayer of legendLayers$ | async; let index = index\">\n      <div class=\"m-layer-legend__title\" [class.-hidden]=\"!legendTabOpen\">\n        {{ geoLayer.title }}\n        <ng-container *ngIf=\"isLayerRendered(geoLayer)\">\n          <button class=\"m-layer-legend__toggle\" (click)=\"toggleLegend(index)\">\n            <pry-icon\n              [iconSvg]=\"legendTab === index ? 'chevron_top' : 'chevron_bottom'\"\n              [width]=\"22\"\n              [height]=\"22\"\n            ></pry-icon>\n          </button>\n        </ng-container>\n        <ng-container *ngIf=\"!isLayerRendered(geoLayer)\">\n          <pry-icon [iconSvg]=\"'close'\" [width]=\"22\" [height]=\"22\"></pry-icon>\n        </ng-container>\n      </div>\n      <div\n        class=\"m-layer-legend__image\"\n        [class.-hidden]=\"!legendTabOpen || legendTab !== index || !isLayerRendered(geoLayer)\"\n      >\n        <ng-container *ngIf=\"!imageNotProvided[index] && (geoLayer | legendUrl)\">\n          <img\n            [src]=\"geoLayer | legendUrl\"\n            [alt]=\"'@pry.widget.map.legend' | i18n: { layer: geoLayer.title }\"\n            (error)=\"imageNotProvided[index] = true\"\n          />\n        </ng-container>\n        <ng-container *ngIf=\"imageNotProvided[index]\">\n          <p class=\"m-layer-legend__error\">{{ '@pry.widget.map.legendNotProvided' | i18n }}</p>\n        </ng-container>\n      </div>\n    </ng-container>\n  </div>\n\n  <div [style.height.px]=\"height$ | async\" class=\"o-map-wrapper\">\n    <div class=\"o-map\">\n      <div #map id=\"map\"></div>\n    </div>\n  </div>\n\n  <ng-template #infoTooltipAction let-action=\"action\">\n    <div class=\"m-tooltip\" role=\"tooltip\" id=\"infoTooltipAction\" aria-hidden=\"true\">\n      <span class=\"m-tooltip__text\">{{ '@pry.widget.map.' + action | i18n }}</span>\n    </div>\n  </ng-template>\n\n  <ng-template #infoTooltipDown>\n    <div class=\"m-tooltip\" role=\"tooltip\" id=\"infoTooltipDown_widgetMap\" aria-hidden=\"true\">\n      <span class=\"m-tooltip__text\">{{ '@pry.widget.map.export' | i18n }}</span>\n    </div>\n  </ng-template>\n\n  <ng-template #infoTooltipLoad>\n    <div class=\"m-tooltip\" role=\"tooltip\" id=\"infoTooltipLoad_widgetMap\" aria-hidden=\"true\">\n      <span class=\"m-tooltip__text\">{{ '@pry.widget.map.import' | i18n }}</span>\n    </div>\n  </ng-template>\n\n  <div #popup class=\"m-tooltip m-tooltip--popup\" [hidden]=\"true\" role=\"tooltip\">\n    <div #popupContent></div>\n  </div>\n  <div\n    #address\n    class=\"m-tooltip m-tooltip--address tooltip-address\"\n    [style.display]=\"'none'\"\n    (click)=\"hideAddress()\"\n  ></div>\n  <ng-template\n    #exportTypeTemplate\n    class=\"m-context-menu-wrapper\"\n    id=\"export_type\"\n    aria-hidden=\"true\"\n    aria-label=\"TODO-access\"\n    aria-labelledby=\"export_card\"\n  >\n    <div class=\"m-context-menu\">\n      <ul class=\"m-context-menu__list\">\n        <li class=\"m-context-menu__list__item\">\n          <button type=\"button\" class=\"a-btn -link-like\" (click)=\"export('png')\">\n            <span class=\"u-visually-hidden\">{{ '@pry.action.exportAsFormat' | i18n }} </span> PNG\n          </button>\n        </li>\n        <li class=\"m-context-menu__list__item\">\n          <button type=\"button\" class=\"a-btn -link-like\" (click)=\"export('kml')\">\n            <span class=\"u-visually-hidden\">{{ '@pry.action.exportAsFormat' | i18n }} </span> KML\n          </button>\n        </li>\n        <li class=\"m-context-menu__list__item\">\n          <button type=\"button\" class=\"a-btn -link-like\" (click)=\"export('geoJSON')\">\n            <span class=\"u-visually-hidden\">{{ '@pry.action.exportAsFormat' | i18n }} </span> GeoJSON\n          </button>\n        </li>\n      </ul>\n    </div>\n  </ng-template>\n</div>\n"]}