@provoly/dashboard 0.18.5 → 0.18.6

package/fesm2022/provoly-dashboard-widgets-widget-map.mjs

@@ -6,7 +6,7 @@ import { Injectable, Component, ViewEncapsulation, Pipe, ViewContainerRef, Templ
 import * as i5 from '@angular/forms';
 import { FormsModule } from '@angular/forms';
 import * as i2 from '@provoly/dashboard';
-import { widgetMapConfig, DashboardActions, ContextMenuActions, TooltipMode, ItemUtils, FieldType, DEFAULT_PROJECTION, ClassSelectors, FieldSelectors, DataWidgetComponent, WIDGET_HEADER_HEIGHT, NamedQueryTypes, DashboardSelectors, ConfigSelectors, DatasourceUtils, GeoMetadata, GeometricFieldTypes, Operation, DataSourceSelectors, ResultsetUtils, PRY_GEOAUTH_TOKEN, BaseWidgetModule, PryCoreModule, PryDashboardModule, PrySelectModule, PryIconModule, PryToggleModule, PryOverlayModule, PryI18nModule, PryRangeModule } from '@provoly/dashboard';
+import { widgetMapConfig, DashboardActions, ContextMenuActions, TooltipMode, DEFAULT_PROJECTION, ItemUtils, FieldType, ClassSelectors, FieldSelectors, DataWidgetComponent, WIDGET_HEADER_HEIGHT, NamedQueryTypes, DashboardSelectors, ConfigSelectors, DatasourceUtils, GeoMetadata, GeometricFieldTypes, Operation, DataSourceSelectors, ResultsetUtils, PRY_GEOAUTH_TOKEN, BaseWidgetModule, PryCoreModule, PryDashboardModule, PrySelectModule, PryIconModule, PryToggleModule, PryOverlayModule, PryI18nModule, PryRangeModule } from '@provoly/dashboard';
 import * as i6 from '@provoly/dashboard/components/checkbox';
 import { PryCheckboxModule } from '@provoly/dashboard/components/checkbox';
 import equal from 'fast-deep-equal/es6';
@@ -27,11 +27,11 @@ import VectorTileLayer from 'ol/layer/VectorTile';
 import RenderBox from 'ol/render/Box';
 import VectorSource from 'ol/source/Vector';
 import { Style, Fill, Stroke, Circle, Text } from 'ol/style';
+import MapboxVectorLayer from 'ol/layer/MapboxVector';
 import { GeoJSON, MVT } from 'ol/format';
 import VectorTile from 'ol/source/VectorTile';
 import CircleStyle from 'ol/style/Circle';
 import WMTSTileGrid from 'ol/tilegrid/WMTS';
-import MapboxVectorLayer from 'ol/layer/MapboxVector';
 import * as i1 from '@ngrx/store';
 
 class SelectionInteraction extends PointerInteraction {
@@ -346,6 +346,80 @@ class CqlUtils {
     }
 }
 
+class XMLUtils {
+    static find(childs, name) {
+        if (!!childs) {
+            for (let i = 0; i < childs.length; i++) {
+                const node = childs[i];
+                if (node.nodeName === name) {
+                    return node;
+                }
+            }
+        }
+        return null;
+    }
+    static findAll(childs, name) {
+        const result = [];
+        for (let i = 0; i < childs.length; i++) {
+            const node = childs[i];
+            if (node.nodeName === name) {
+                result.push(node);
+            }
+        }
+        return result;
+    }
+    static findWith(childs, attribute, value) {
+        for (let i = 0; i < childs.length; i++) {
+            const node = childs[i];
+            const attrNode = XMLUtils.find(node.childNodes, attribute);
+            if (attrNode?.textContent === value) {
+                return node;
+            }
+        }
+        return null;
+    }
+    static getMatchingLayer(paramLayer, doc) {
+        const WMSCapability = XMLUtils.find(doc.childNodes, 'WMS_Capabilities');
+        if (WMSCapability) {
+            const Capabilities = XMLUtils.find(WMSCapability.childNodes, 'Capability');
+            if (Capabilities) {
+                const Layer = XMLUtils.find(Capabilities.childNodes, 'Layer');
+                if (Layer) {
+                    let matchingLayer = XMLUtils.findWith(Layer.childNodes, 'Name', paramLayer);
+                    const split = paramLayer.split(':');
+                    if (!matchingLayer && split.length >= 2) {
+                        // Try again, splitting on ":" in the name to ignore namespace if present
+                        matchingLayer = XMLUtils.findWith(Layer.childNodes, 'Name', split[split.length - 1]);
+                    }
+                    return matchingLayer;
+                }
+            }
+        }
+        return null;
+    }
+    static getLayerExtent(paramLayer, map, doc) {
+        if (!doc) {
+            return null;
+        }
+        const matchingLayer = XMLUtils.getMatchingLayer(paramLayer, doc);
+        if (matchingLayer) {
+            const boundingBox = XMLUtils.find(matchingLayer.childNodes, 'BoundingBox');
+            if (boundingBox) {
+                // @ts-ignore
+                const attributes = boundingBox.attributes;
+                const projBox = get(attributes.CRS.textContent ?? DEFAULT_PROJECTION);
+                if (projBox) {
+                    return [
+                        transform([parseFloat(attributes.minx.textContent), parseFloat(attributes.miny.textContent)], projBox, map.getView().getProjection()),
+                        transform([parseFloat(attributes.maxx.textContent), parseFloat(attributes.maxy.textContent)], projBox, map.getView().getProjection())
+                    ];
+                }
+            }
+        }
+        return null;
+    }
+}
+
 class WidgetMapLayerService {
     constructor() {
         this.styleCache = {};
@@ -400,12 +474,12 @@ class WidgetMapLayerService {
             },
             heatmap: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
                 const heatmap = new Heatmap({
-                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
-                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    minZoom: layer.minZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MAX,
                     opacity: (layer.opacity ?? 100) / 100,
                     source: new Vector({ attributions: [layer.attribution ?? ''] }),
-                    blur: (layer.radius ?? DEFAULT_HEATMAP_RADIUS) / 2,
-                    radius: layer.radius ?? DEFAULT_HEATMAP_RADIUS,
+                    blur: (layer.radius ?? WidgetMapUtils.DEFAULT_HEATMAP_RADIUS) / 2,
+                    radius: layer.radius ?? WidgetMapUtils.DEFAULT_HEATMAP_RADIUS,
                     weight: (feature) => {
                         const value = ItemUtils.getAttributeCalculatedValue(feature, attributesForClass[feature.get('oClass')].intensityAttribute);
                         const atScale = (value - range.min) / (range.max - range.min);
@@ -415,32 +489,32 @@ class WidgetMapLayerService {
                 layerClassesId.forEach((classId) => {
                     (resultSet.items[classId] || [])
                         .filter((item) => {
-                        const location = ItemUtils.readGeometry(item, 'point', attributesForClass[classId].locationAttribute);
+                        const location = WidgetMapUtils.readGeometry(map.getView().getProjection(), item, 'point', attributesForClass[classId].locationAttribute);
                         return !!location;
                     })
                         .forEach((item) => {
                         heatmap
                             .getSource()
-                            ?.addFeature(getFeatureFromItem(item, 'heatpoint', attributesForClass[item.oClass].locationAttribute));
+                            ?.addFeature(WidgetMapUtils.getFeatureFromItem(map.getView().getProjection(), item, 'heatpoint', attributesForClass[item.oClass].locationAttribute));
                     });
                 });
                 return heatmap;
             },
             marker: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
                 const vectorLayer = new VectorLayer({
-                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
-                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    minZoom: layer.minZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MAX,
                     opacity: (layer.opacity ?? 100) / 100,
                     source: new VectorSource({ attributions: [layer.attribution ?? ''] })
                 });
                 layerClassesId.forEach((classId) => {
                     (resultSet.items[classId] || [])
                         .filter((item) => {
-                        const location = ItemUtils.readGeometry(item, 'point', attributesForClass[item.oClass].locationAttribute);
+                        const location = WidgetMapUtils.readGeometry(map.getView().getProjection(), item, 'point', attributesForClass[item.oClass].locationAttribute);
                         return !!location;
                     })
                         .forEach(async (item) => {
-                        const itemFeature = getFeatureFromItem(item, 'marker', attributesForClass[item.oClass].locationAttribute, itemStyles[item.id]?.classic, itemStyles[item.id]?.bordered);
+                        const itemFeature = WidgetMapUtils.getFeatureFromItem(map.getView().getProjection(), item, 'marker', attributesForClass[item.oClass].locationAttribute, itemStyles[item.id]?.classic, itemStyles[item.id]?.bordered);
                         itemFeature.setStyle(itemFeature.get('classicStyle'));
                         vectorLayer.getSource()?.addFeature(itemFeature);
                     });
@@ -448,37 +522,38 @@ class WidgetMapLayerService {
                 return this.makeClustered(vectorLayer, layer);
             },
             point: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
-                return this.layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, 'point');
+                return this.layerFromGeoJsonGeometry(map.getView().getProjection(), layer, layerClassesId, resultSet, attributesForClass, 'point');
             },
             line: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
-                return this.layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, 'line');
+                return this.layerFromGeoJsonGeometry(map.getView().getProjection(), layer, layerClassesId, resultSet, attributesForClass, 'line');
             },
             'multi-line': (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
-                return this.layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, 'multi-line');
+                return this.layerFromGeoJsonGeometry(map.getView().getProjection(), layer, layerClassesId, resultSet, attributesForClass, 'multi-line');
             },
             polygon: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
-                return this.layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, 'polygon');
+                return this.layerFromGeoJsonGeometry(map.getView().getProjection(), layer, layerClassesId, resultSet, attributesForClass, 'polygon');
             },
             'multi-polygon': (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
-                return this.layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, 'multi-polygon');
+                return this.layerFromGeoJsonGeometry(map.getView().getProjection(), layer, layerClassesId, resultSet, attributesForClass, 'multi-polygon');
             },
             bubble: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
                 const bubbleLayer = new VectorLayer({
-                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
-                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    minZoom: layer.minZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MAX,
                     opacity: (layer.opacity ?? 100) / 100,
                     source: new VectorSource({ attributions: [layer.attribution ?? ''] })
                 });
                 layerClassesId.forEach((classId) => {
                     (resultSet.items[classId] || [])
                         .filter((item) => {
-                        const location = ItemUtils.readGeometry(item, 'point', attributesForClass[item.oClass].locationAttribute);
+                        const location = WidgetMapUtils.readGeometry(map.getView().getProjection(), item, 'point', attributesForClass[item.oClass].locationAttribute);
                         return !!location;
                     })
                         .forEach((item) => {
                         const value = ItemUtils.getAttributeCalculatedValue(item, attributesForClass[item.oClass].intensityAttribute);
                         const atScale = (value - range.min) / (range.max - range.min);
-                        const itemFeature = getCircleFeatureFromItem(item, attributesForClass[item.oClass].locationAttribute, (layer.intensityAsc ? atScale : 1 - atScale) * (layer.radiusFactor ?? DEFAULT_RADIUS_INTENSITY_FACTOR), this.circleStyle, this.selectedCircleStyle);
+                        const itemFeature = WidgetMapUtils.getCircleFeatureFromItem(map.getView().getProjection(), item, attributesForClass[item.oClass].locationAttribute, (layer.intensityAsc ? atScale : 1 - atScale) *
+                            (layer.radiusFactor ?? WidgetMapUtils.DEFAULT_RADIUS_INTENSITY_FACTOR), this.circleStyle, this.selectedCircleStyle);
                         itemFeature.setStyle(itemFeature.get('classicStyle'));
                         bubbleLayer.getSource()?.addFeature(itemFeature);
                     });
@@ -487,16 +562,16 @@ class WidgetMapLayerService {
             },
             relation: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
                 return new VectorLayer({
-                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
-                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    minZoom: layer.minZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MAX,
                     opacity: (layer.opacity ?? 100) / 100,
                     source: new VectorSource({ attributions: [layer.attribution ?? ''] })
                 });
             },
             wms: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
                 const impl = new Tile({
-                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
-                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    minZoom: layer.minZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MAX,
                     opacity: (layer.opacity ?? 100) / 100,
                     source: new TileWMS({
                         attributions: [layer.attribution ?? ''],
@@ -524,8 +599,8 @@ class WidgetMapLayerService {
                     matrixIds[z] = z;
                 }
                 return new Tile({
-                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
-                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    minZoom: layer.minZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MAX,
                     opacity: (layer.opacity ?? 100) / 100,
                     source: new WMTS({
                         attributions: [layer.attribution ?? ''],
@@ -552,8 +627,8 @@ class WidgetMapLayerService {
             },
             featurelayer: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
                 return new VectorLayer({
-                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
-                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    minZoom: layer.minZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MAX,
                     opacity: (layer.opacity ?? 100) / 100,
                     source: new VectorSource({
                         attributions: [layer.attribution ?? ''],
@@ -564,8 +639,8 @@ class WidgetMapLayerService {
             },
             vectortile: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
                 return new VectorTileLayer({
-                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
-                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    minZoom: layer.minZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MAX,
                     opacity: (layer.opacity ?? 100) / 100,
                     source: new VectorTile({
                         attributions: [layer.attribution ?? ''],
@@ -576,8 +651,8 @@ class WidgetMapLayerService {
             },
             rastertile: (layer, attributesForClass, layerClassesId, resultSet, range, itemStyles, map) => {
                 return new Tile({
-                    minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
-                    maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+                    minZoom: layer.minZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MIN,
+                    maxZoom: layer.maxZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MAX,
                     opacity: (layer.opacity ?? 100) / 100,
                     source: new XYZ({
                         url: layer.url,
@@ -593,10 +668,10 @@ class WidgetMapLayerService {
     get implementationList() {
         return Object.keys(this.layersImplementation).filter((implementation) => implementation !== 'geoserver');
     }
-    layerFromGeoJsonGeometry(layer, layerClassesId, resultSet, attributesForClass, type) {
+    layerFromGeoJsonGeometry(projection, layer, layerClassesId, resultSet, attributesForClass, type) {
         const vectorLayer = new VectorLayer({
-            minZoom: layer.minZoom ?? DEFAULT_ZOOM_MIN,
-            maxZoom: layer.maxZoom ?? DEFAULT_ZOOM_MAX,
+            minZoom: layer.minZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MIN,
+            maxZoom: layer.maxZoom ?? WidgetMapUtils.DEFAULT_ZOOM_MAX,
             opacity: (layer.opacity ?? 100) / 100,
             source: new VectorSource({ attributions: [layer.attribution ?? ''] })
         });
@@ -604,14 +679,14 @@ class WidgetMapLayerService {
             (resultSet.items[classId] || [])
                 .map((item) => ({
                 item,
-                location: ItemUtils.readGeometry(item, type, attributesForClass[item.oClass].locationAttribute)
+                location: WidgetMapUtils.readGeometry(projection, item, type, attributesForClass[item.oClass].locationAttribute)
             }))
                 .filter(({ location }) => !!location)
                 .forEach(async (subItem) => {
                 const itemFeature = new Feature({
                     ...subItem.item,
                     type,
-                    geometry: subItem.location,
+                    geometry: subItem.location ?? undefined,
                     classicStyle: type === 'point' ? this.pointStyle : this.circleStyle,
                     selectedStyle: type === 'point' ? this.selectedPointStyle : this.selectedCircleStyle
                 });
@@ -686,310 +761,281 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImpor
                 }]
         }] });
 
-const populateLocationAttribute = (layer, resultSet, classesNotFiltered, fields) => {
-    if (['heatmap', 'marker', 'bubble', 'point', 'line', 'polygon', 'multi-line', 'multi-polygon', 'auto'].includes(layer.type) &&
-        !!resultSet &&
-        !!classesNotFiltered &&
-        classesNotFiltered.length > 0) {
-        const specificLayer = layer;
-        const classes = classesNotFiltered.filter((cl) => specificLayer.classes?.includes(cl.id) || !specificLayer.classes || specificLayer.classes.length === 0);
-        if (!specificLayer.attribute) {
-            // No location attribute available, then try to guess one that will be ok
-            const geometry = geometryForLayer(layer);
-            let candidates = [];
-            if (Object.keys(resultSet.items).length > 0) {
-                // Based on items that we have to display
-                candidates = Object.keys(resultSet.items)
-                    .map((key) => ({ items: resultSet.items[key], oClass: classes.find((cl) => cl.id === key) }))
-                    .map(({ items, oClass }) => (oClass ?? { attributes: [] }).attributes
-                    .map((attr) => ({ attr, field: fields.find((f) => f.id === attr.field) }))
-                    .filter((attr) => attr.field?.type === geometry))
-                    .reduce((p, c) => [...p, ...c], []);
-            }
-            else {
-                // We don't have any items to display, so allow all corresponding geometry fields
-                candidates = classesNotFiltered
-                    .map((clazz) => clazz.attributes)
-                    .flat()
-                    .map((attr) => ({ attr, field: fields.find((field) => field.id === attr.field) }))
-                    .filter(({ attr, field }) => field?.type === geometry);
-            }
-            if (candidates.length > 0) {
-                specificLayer.attribute = candidates[0].attr.name;
+class WidgetMapUtils {
+    static populateLocationAttribute(layer, resultSet, classesNotFiltered, fields) {
+        if (['heatmap', 'marker', 'bubble', 'point', 'line', 'polygon', 'multi-line', 'multi-polygon', 'auto'].includes(layer.type) &&
+            !!resultSet &&
+            !!classesNotFiltered &&
+            classesNotFiltered.length > 0) {
+            const specificLayer = layer;
+            const classes = classesNotFiltered.filter((cl) => specificLayer.classes?.includes(cl.id) || !specificLayer.classes || specificLayer.classes.length === 0);
+            if (!specificLayer.attribute) {
+                // No location attribute available, then try to guess one that will be ok
+                const geometry = WidgetMapUtils.geometryForLayer(layer);
+                let candidates = [];
+                if (Object.keys(resultSet.items).length > 0) {
+                    // Based on items that we have to display
+                    candidates = Object.keys(resultSet.items)
+                        .map((key) => ({ items: resultSet.items[key], oClass: classes.find((cl) => cl.id === key) }))
+                        .map(({ items, oClass }) => (oClass ?? { attributes: [] }).attributes
+                        .map((attr) => ({ attr, field: fields.find((f) => f.id === attr.field) }))
+                        .filter((attr) => attr.field?.type === geometry))
+                        .reduce((p, c) => [...p, ...c], []);
+                }
+                else {
+                    // We don't have any items to display, so allow all corresponding geometry fields
+                    candidates = classesNotFiltered
+                        .map((clazz) => clazz.attributes)
+                        .flat()
+                        .map((attr) => ({ attr, field: fields.find((field) => field.id === attr.field) }))
+                        .filter(({ attr, field }) => field?.type === geometry);
+                }
+                if (candidates.length > 0) {
+                    specificLayer.attribute = candidates[0].attr.name;
+                }
             }
         }
     }
-};
-const populateIntensityAttribute = (layer, resultSet, classesNotFiltered, fields) => {
-    if (['heatmap', 'bubble'].includes(layer.type) &&
-        !!resultSet &&
-        !!classesNotFiltered &&
-        classesNotFiltered.length > 0) {
-        const specificLayer = layer;
-        const classes = classesNotFiltered.filter((cl) => (specificLayer.classes?.includes(cl.id) || !specificLayer.classes || specificLayer.classes.length === 0) &&
-            cl.attributes.find((attr) => attr.name === (specificLayer?.attribute ?? [])));
-        if (!specificLayer.intensityAttribute) {
-            // No intensity attribute available, then take the maximum intensity matching attribute
-            const candidatesDry = Object.keys(resultSet.items)
-                .map((key) => ({ items: resultSet.items[key], oClass: classes.find((cl) => cl.id === key) }))
-                .map(({ items, oClass }) => {
-                return (oClass ?? { attributes: [] }).attributes
-                    .map((attr) => ({ attr, field: fields.find((f) => f.id === attr.field) }))
-                    .filter((attr) => attr.field?.type === FieldType.DECIMAL || attr.field?.type === FieldType.INTEGER)
-                    .map((attr) => {
-                    const attrValues = ItemUtils.pertinentValue(items, attr.attr);
-                    return {
-                        min: Math.min(...attrValues),
-                        max: Math.max(...attrValues),
-                        name: attr.attr.name
-                    };
-                });
-            })
-                .reduce((p, c) => [...p, ...c], [])
-                .sort((a, b) => b.max - a.max);
-            if (candidatesDry.length > 0) {
-                specificLayer.intensityAttribute = candidatesDry[0].name;
-                specificLayer.intensityAsc = true;
+    static populateIntensityAttribute(layer, resultSet, classesNotFiltered, fields) {
+        if (['heatmap', 'bubble'].includes(layer.type) &&
+            !!resultSet &&
+            !!classesNotFiltered &&
+            classesNotFiltered.length > 0) {
+            const specificLayer = layer;
+            const classes = classesNotFiltered.filter((cl) => (specificLayer.classes?.includes(cl.id) || !specificLayer.classes || specificLayer.classes.length === 0) &&
+                cl.attributes.find((attr) => attr.name === (specificLayer?.attribute ?? [])));
+            if (!specificLayer.intensityAttribute) {
+                // No intensity attribute available, then take the maximum intensity matching attribute
+                const candidatesDry = Object.keys(resultSet.items)
+                    .map((key) => ({ items: resultSet.items[key], oClass: classes.find((cl) => cl.id === key) }))
+                    .map(({ items, oClass }) => {
+                    return (oClass ?? { attributes: [] }).attributes
+                        .map((attr) => ({ attr, field: fields.find((f) => f.id === attr.field) }))
+                        .filter((attr) => attr.field?.type === FieldType.DECIMAL || attr.field?.type === FieldType.INTEGER)
+                        .map((attr) => {
+                        const attrValues = ItemUtils.pertinentValue(items, attr.attr);
+                        return {
+                            min: Math.min(...attrValues),
+                            max: Math.max(...attrValues),
+                            name: attr.attr.name
+                        };
+                    });
+                })
+                    .reduce((p, c) => [...p, ...c], [])
+                    .sort((a, b) => b.max - a.max);
+                if (candidatesDry.length > 0) {
+                    specificLayer.intensityAttribute = candidatesDry[0].name;
+                    specificLayer.intensityAsc = true;
+                }
             }
         }
     }
-};
-const getFeatureFromItem = (item, type, locationAttribute, iconStyle, selectedIconStyle) => {
-    return new Feature({
-        ...item,
-        type,
-        geometry: ItemUtils.readGeometry(item, 'point', locationAttribute),
-        classicStyle: iconStyle ?? null,
-        selectedStyle: selectedIconStyle ?? null
-    });
-};
-const getCircleFeatureFromItem = (item, locationAttribute, radius, iconStyle, selectedIconStyle) => {
-    return new Feature({
-        ...item,
-        geometry: new Circle$1(ItemUtils.readGeometry(item, 'point', locationAttribute).getCoordinates(), radius),
-        classicStyle: iconStyle,
-        selectedStyle: selectedIconStyle,
-        type: 'bubble'
-    });
-};
-const getLinkFeature = (relation, featureSource, featureDestination) => {
-    return new Feature({
-        ...relation,
-        geometry: new LineString([
-            // @ts-ignore
-            featureSource.getGeometry()?.getCoordinates() ?? featureSource.getGeometry()?.getCenter() ?? [0, 0],
-            // @ts-ignore
-            featureDestination.getGeometry()?.getCoordinates() ?? featureDestination.getGeometry()?.getCenter() ?? [0, 0]
-        ]),
-        source: featureSource,
-        destination: featureDestination,
-        type: 'link'
-    });
-};
-const getMapAsPng = (map) => {
-    return new Promise((resolve, reject) => {
-        map.once('rendercomplete', function () {
-            const mapCanvas = document.createElement('canvas');
-            const size = map.getSize() || [100, 100];
-            mapCanvas.width = size[0];
-            mapCanvas.height = size[1];
-            const mapContext = mapCanvas.getContext('2d') || null;
-            Array.prototype.forEach.call(document.querySelectorAll('.ol-layer canvas, canvas.ol-layer'), (canvas) => {
-                if (canvas.width > 0) {
-                    const opacity = canvas.parentNode.style.opacity || canvas.style.opacity;
-                    mapContext.globalAlpha = opacity === '' ? 1 : Number(opacity);
-                    const backgroundColor = canvas.parentNode.style.backgroundColor;
-                    if (backgroundColor) {
-                        mapContext.fillStyle = backgroundColor;
-                        mapContext.fillRect(0, 0, canvas.width, canvas.height);
-                    }
-                    let matrix;
-                    const transform = canvas.style.transform;
-                    if (transform) {
-                        // Get the transform parameters from the style's transform matrix
-                        matrix = transform
-                            .match(/^matrix\(([^(]*)\)$/)[1]
-                            .split(',')
-                            .map(Number);
-                    }
-                    else {
-                        matrix = [
-                            parseFloat(canvas.style.width) / canvas.width,
-                            0,
-                            0,
-                            parseFloat(canvas.style.height) / canvas.height,
-                            0,
-                            0
-                        ];
+    static getFeatureFromItem(projection, item, type, locationAttribute, iconStyle, selectedIconStyle) {
+        return new Feature({
+            ...item,
+            type,
+            geometry: WidgetMapUtils.readGeometry(projection, item, 'point', locationAttribute) ?? undefined,
+            classicStyle: iconStyle ?? null,
+            selectedStyle: selectedIconStyle ?? null
+        });
+    }
+    static getCircleFeatureFromItem(projection, item, locationAttribute, radius, iconStyle, selectedIconStyle) {
+        return new Feature({
+            ...item,
+            geometry: new Circle$1(WidgetMapUtils.readGeometry(projection, item, 'point', locationAttribute).getCoordinates(), radius),
+            classicStyle: iconStyle,
+            selectedStyle: selectedIconStyle,
+            type: 'bubble'
+        });
+    }
+    static getLinkFeature(relation, featureSource, featureDestination) {
+        return new Feature({
+            ...relation,
+            geometry: new LineString([
+                // @ts-ignore
+                featureSource.getGeometry()?.getCoordinates() ?? featureSource.getGeometry()?.getCenter() ?? [0, 0],
+                // @ts-ignore
+                featureDestination.getGeometry()?.getCoordinates() ?? featureDestination.getGeometry()?.getCenter() ?? [0, 0]
+            ]),
+            source: featureSource,
+            destination: featureDestination,
+            type: 'link'
+        });
+    }
+    static getMapAsPng(map) {
+        return new Promise((resolve, reject) => {
+            map.once('rendercomplete', function () {
+                const mapCanvas = document.createElement('canvas');
+                const size = map.getSize() || [100, 100];
+                mapCanvas.width = size[0];
+                mapCanvas.height = size[1];
+                const mapContext = mapCanvas.getContext('2d') || null;
+                Array.prototype.forEach.call(document.querySelectorAll('.ol-layer canvas, canvas.ol-layer'), (canvas) => {
+                    if (canvas.width > 0) {
+                        const opacity = canvas.parentNode.style.opacity || canvas.style.opacity;
+                        mapContext.globalAlpha = opacity === '' ? 1 : Number(opacity);
+                        const backgroundColor = canvas.parentNode.style.backgroundColor;
+                        if (backgroundColor) {
+                            mapContext.fillStyle = backgroundColor;
+                            mapContext.fillRect(0, 0, canvas.width, canvas.height);
+                        }
+                        let matrix;
+                        const transform = canvas.style.transform;
+                        if (transform) {
+                            // Get the transform parameters from the style's transform matrix
+                            matrix = transform
+                                .match(/^matrix\(([^(]*)\)$/)[1]
+                                .split(',')
+                                .map(Number);
+                        }
+                        else {
+                            matrix = [
+                                parseFloat(canvas.style.width) / canvas.width,
+                                0,
+                                0,
+                                parseFloat(canvas.style.height) / canvas.height,
+                                0,
+                                0
+                            ];
+                        }
+                        // Apply the transform to the export map context
+                        CanvasRenderingContext2D.prototype.setTransform.apply(mapContext, matrix);
+                        mapContext.drawImage(canvas, 0, 0);
                     }
-                    // Apply the transform to the export map context
-                    CanvasRenderingContext2D.prototype.setTransform.apply(mapContext, matrix);
-                    mapContext.drawImage(canvas, 0, 0);
-                }
+                });
+                mapContext.globalAlpha = 1;
+                resolve(mapCanvas.toDataURL('image/png'));
             });
-            mapContext.globalAlpha = 1;
-            resolve(mapCanvas.toDataURL('image/png'));
+            map.renderSync();
         });
-        map.renderSync();
-    });
-};
-const exportMapAsImage = (map, filename) => {
-    getMapAsPng(map).then((data) => {
-        const link = document.createElement('a');
-        link.download = filename;
-        link.href = data;
-        link.click();
-    });
-};
-const geometryForLayer = (layer) => {
-    switch (layer.type) {
-        case 'marker':
-        case 'heatmap':
-        case 'bubble':
-        case 'point':
-            return FieldType.POINT;
-        case 'line':
-            return FieldType.LINE;
-        case 'polygon':
-            return FieldType.POLYGON;
-        case 'multi-line':
-            return FieldType.MULTILINE;
-        case 'multi-polygon':
-            return FieldType.MULTIPOLYGON;
-        case 'auto':
-            return geometryForLayer({
-                type: WidgetMapLayerService.translateFieldTypeToLayerType(layer.subType)
-            });
-        default:
-            return FieldType.POINT;
     }
-};
-const assignLayersOrder = (_layers) => {
-    const layers = JSON.parse(JSON.stringify(_layers));
-    layers.sort((l1, l2) => (l2.background ? 0 : 1) - (l1.background ? 0 : 1));
-    // Assign sure things
-    layers.forEach((layer, index) => {
-        if (layer.background) {
-            layer.order = BACKGROUND_ORDER;
-        }
-        if (index === 0 && !layer.order) {
-            layer.order = 0;
+    static exportMapAsImage(map, filename) {
+        WidgetMapUtils.getMapAsPng(map).then((data) => {
+            const link = document.createElement('a');
+            link.download = filename;
+            link.href = data;
+            link.click();
+        });
+    }
+    static geometryForLayer(layer) {
+        switch (layer.type) {
+            case 'marker':
+            case 'heatmap':
+            case 'bubble':
+            case 'point':
+                return FieldType.POINT;
+            case 'line':
+                return FieldType.LINE;
+            case 'polygon':
+                return FieldType.POLYGON;
+            case 'multi-line':
+                return FieldType.MULTILINE;
+            case 'multi-polygon':
+                return FieldType.MULTIPOLYGON;
+            case 'auto':
+                return WidgetMapUtils.geometryForLayer({
+                    type: WidgetMapLayerService.translateFieldTypeToLayerType(layer.subType)
+                });
+            default:
+                return FieldType.POINT;
         }
-    });
-    layers.forEach((layer, index) => {
-        if (layer.order === undefined) {
-            let [distanceToFirstPreviousOrder, distanceToFirstNextOrder] = [
-                layers
-                    .slice(0, index)
-                    .reverse()
-                    .findIndex((element) => element.order !== undefined) + 1,
-                layers.slice(index + 1).findIndex((element) => element.order !== undefined)
-            ];
-            let [previousOrderIndex, nextOrderIndex] = [
-                distanceToFirstPreviousOrder > -1 ? index - distanceToFirstPreviousOrder : 0,
-                distanceToFirstNextOrder + index + 1
-            ];
-            let [previousOrder, nextOrder] = [
-                distanceToFirstPreviousOrder > -1 ? layers[previousOrderIndex].order : 0,
-                distanceToFirstNextOrder > -1 ? layers[nextOrderIndex].order : -1
-            ];
-            if (nextOrder > 0 && nextOrder < previousOrder) {
-                const newOrder = previousOrder + (nextOrderIndex - previousOrderIndex);
-                console.warn(`the order property of layer no ${index + 2} was preset but doesn't follow the order of the other layers`);
-                nextOrder = newOrder;
-            }
-            if (nextOrder > 0) {
-                let relativeIndex = index - previousOrderIndex;
-                layer.order =
-                    previousOrder + ((nextOrder - previousOrder) / (nextOrderIndex - previousOrderIndex)) * relativeIndex;
+    }
+    static assignLayersOrder(_layers) {
+        const layers = JSON.parse(JSON.stringify(_layers));
+        layers.sort((l1, l2) => (l2.background ? 0 : 1) - (l1.background ? 0 : 1));
+        // Assign sure things
+        layers.forEach((layer, index) => {
+            if (layer.background) {
+                layer.order = WidgetMapUtils.BACKGROUND_ORDER;
             }
-            else {
-                layer.order = previousOrder + distanceToFirstPreviousOrder;
+            if (index === 0 && !layer.order) {
+                layer.order = 0;
             }
-        }
-    });
-    return layers.sort((l1, l2) => (l1.order ?? 1) - (l2.order ?? 1));
-};
-const DEFAULT_HEATMAP_RADIUS = 25;
-const DEFAULT_RADIUS_INTENSITY_FACTOR = 10000;
-const DEFAULT_ZOOM_MIN = 3;
-const DEFAULT_ZOOM_START = 10;
-const DEFAULT_ZOOM_MAX = 18;
-const DEFAULT_MAP_CENTER = [2.2827217347381525, 48.864706031557716];
-const BACKGROUND_ORDER = 9999;
-
-class XMLUtils {
-    static find(childs, name) {
-        if (!!childs) {
-            for (let i = 0; i < childs.length; i++) {
-                const node = childs[i];
-                if (node.nodeName === name) {
-                    return node;
+        });
+        layers.forEach((layer, index) => {
+            if (layer.order === undefined) {
+                let [distanceToFirstPreviousOrder, distanceToFirstNextOrder] = [
+                    layers
+                        .slice(0, index)
+                        .reverse()
+                        .findIndex((element) => element.order !== undefined) + 1,
+                    layers.slice(index + 1).findIndex((element) => element.order !== undefined)
+                ];
+                let [previousOrderIndex, nextOrderIndex] = [
+                    distanceToFirstPreviousOrder > -1 ? index - distanceToFirstPreviousOrder : 0,
+                    distanceToFirstNextOrder + index + 1
+                ];
+                let [previousOrder, nextOrder] = [
+                    distanceToFirstPreviousOrder > -1 ? layers[previousOrderIndex].order : 0,
+                    distanceToFirstNextOrder > -1 ? layers[nextOrderIndex].order : -1
+                ];
+                if (nextOrder > 0 && nextOrder < previousOrder) {
+                    const newOrder = previousOrder + (nextOrderIndex - previousOrderIndex);
+                    console.warn(`the order property of layer no ${index + 2} was preset but doesn't follow the order of the other layers`);
+                    nextOrder = newOrder;
+                }
+                if (nextOrder > 0) {
+                    let relativeIndex = index - previousOrderIndex;
+                    layer.order =
+                        previousOrder + ((nextOrder - previousOrder) / (nextOrderIndex - previousOrderIndex)) * relativeIndex;
+                }
+                else {
+                    layer.order = previousOrder + distanceToFirstPreviousOrder;
                 }
             }
-        }
-        return null;
+        });
+        return layers.sort((l1, l2) => (l1.order ?? 1) - (l2.order ?? 1));
     }
-    static findAll(childs, name) {
-        const result = [];
-        for (let i = 0; i < childs.length; i++) {
-            const node = childs[i];
-            if (node.nodeName === name) {
-                result.push(node);
-            }
+    static readGeometry(projection, item, type, attribute) {
+        if (!attribute || !item.attributes[attribute.name]) {
+            // @ts-ignore
+            return null;
         }
-        return result;
-    }
-    static findWith(childs, attribute, value) {
-        for (let i = 0; i < childs.length; i++) {
-            const node = childs[i];
-            const attrNode = XMLUtils.find(node.childNodes, attribute);
-            if (attrNode?.textContent === value) {
-                return node;
-            }
+        let value = item.attributes[attribute.name];
+        if (value.type === 'MULTI') {
+            value = value.values[0];
         }
-        return null;
-    }
-    static getMatchingLayer(paramLayer, doc) {
-        const WMSCapability = XMLUtils.find(doc.childNodes, 'WMS_Capabilities');
-        if (WMSCapability) {
-            const Capabilities = XMLUtils.find(WMSCapability.childNodes, 'Capability');
-            if (Capabilities) {
-                const Layer = XMLUtils.find(Capabilities.childNodes, 'Layer');
-                if (Layer) {
-                    let matchingLayer = XMLUtils.findWith(Layer.childNodes, 'Name', paramLayer);
-                    const split = paramLayer.split(':');
-                    if (!matchingLayer && split.length >= 2) {
-                        // Try again, splitting on ":" in the name to ignore namespace if present
-                        matchingLayer = XMLUtils.findWith(Layer.childNodes, 'Name', split[split.length - 1]);
-                    }
-                    return matchingLayer;
-                }
-            }
+        let geometry;
+        try {
+            geometry = new GeoJSON().readGeometry(value.value, {
+                featureProjection: projection
+            });
         }
-        return null;
-    }
-    static getLayerExtent(paramLayer, map, doc) {
-        if (!doc) {
-            return null;
+        catch (e) {
+            console.warn('error reading Geometry', value.value, e);
         }
-        const matchingLayer = XMLUtils.getMatchingLayer(paramLayer, doc);
-        if (matchingLayer) {
-            const boundingBox = XMLUtils.find(matchingLayer.childNodes, 'BoundingBox');
-            if (boundingBox) {
-                // @ts-ignore
-                const attributes = boundingBox.attributes;
-                const projBox = get(attributes.CRS.textContent ?? DEFAULT_PROJECTION);
-                if (projBox) {
-                    return [
-                        transform([parseFloat(attributes.minx.textContent), parseFloat(attributes.miny.textContent)], projBox, map.getView().getProjection()),
-                        transform([parseFloat(attributes.maxx.textContent), parseFloat(attributes.maxy.textContent)], projBox, map.getView().getProjection())
-                    ];
-                }
+        return geometry;
+    }
+    static extractGeometries(value, points, type) {
+        const valueSimple = value.value;
+        if (typeof valueSimple !== 'string' && typeof valueSimple !== 'number') {
+            if (type === 'point' && valueSimple.type === FieldType.POINT) {
+                points.push(valueSimple.coordinates);
+            }
+            if (type === 'point' && valueSimple.type === FieldType.MULTIPOINT) {
+                points.push(...valueSimple.coordinates);
+            }
+            if (type === 'line' && valueSimple.type === FieldType.LINE) {
+                points.push(valueSimple.coordinates);
+            }
+            if (type === 'line' && valueSimple.type === FieldType.MULTILINE) {
+                points.push(...valueSimple.coordinates);
+            }
+            if (type === 'polygon' && valueSimple.type === FieldType.POLYGON) {
+                points.push(valueSimple.coordinates);
+            }
+            if (type === 'polygon' && valueSimple.type === FieldType.MULTIPOLYGON) {
+                points.push(...valueSimple.coordinates);
             }
         }
-        return null;
     }
+    static { this.DEFAULT_HEATMAP_RADIUS = 25; }
+    static { this.DEFAULT_RADIUS_INTENSITY_FACTOR = 10000; }
+    static { this.DEFAULT_ZOOM_MIN = 3; }
+    static { this.DEFAULT_ZOOM_START = 10; }
+    static { this.DEFAULT_ZOOM_MAX = 18; }
+    static { this.DEFAULT_MAP_CENTER = [2.2827217347381525, 48.864706031557716]; }
+    static { this.BACKGROUND_ORDER = 9999; }
 }
 
 class PryWidgetMapCssComponent {
@@ -1012,7 +1058,7 @@ class GeometryFieldsForPipe {
     transform(value, ...args) {
         const specificLayer = value;
         const limitToClasses = args[0].classes;
-        const type = geometryForLayer({ type: args[0].type });
+        const type = WidgetMapUtils.geometryForLayer({ type: args[0].type });
         return combineLatest([this.classes$, this.fields$]).pipe(filter(([classes, fields]) => !!classes && !!fields && classes.length > 0 && fields.length > 0), map(([classes, fields]) => {
             const potentialFields = classes
                 .map((cl) => cl.id)
@@ -1236,8 +1282,8 @@ class WidgetMapComponent extends DataWidgetComponent {
                     : [])
             ];
             autoOptions.layers?.forEach((layer, i) => {
-                populateLocationAttribute(layer, resultSet, classes, fields);
-                populateIntensityAttribute(layer, resultSet, classes, fields);
+                WidgetMapUtils.populateLocationAttribute(layer, resultSet, classes, fields);
+                WidgetMapUtils.populateIntensityAttribute(layer, resultSet, classes, fields);
                 if (autoOptions.attributions) {
                     layer.attribution = layer.attribution ?? '';
                 }
@@ -1279,7 +1325,7 @@ class WidgetMapComponent extends DataWidgetComponent {
                     this.emitManifest();
                 }
             }
-            autoOptions.layers = assignLayersOrder(autoOptions.layers);
+            autoOptions.layers = WidgetMapUtils.assignLayersOrder(autoOptions.layers);
             return autoOptions;
         }), distinctUntilChanged((p, c) => equal(p, c)));
         this.subscriptions.add(this.options$.pipe(filter((opt) => !!opt)).subscribe((options) => {
@@ -1348,10 +1394,10 @@ class WidgetMapComponent extends DataWidgetComponent {
         }));
         this.options$
             .pipe(map((options) => ({
-            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
+            center: fromLonLat(options.center ?? WidgetMapUtils.DEFAULT_MAP_CENTER),
+            maxZoom: options.zoom?.max ?? WidgetMapUtils.DEFAULT_ZOOM_MAX,
+            minZoom: options.zoom?.min ?? WidgetMapUtils.DEFAULT_ZOOM_MIN,
+            zoom: options.zoom?.start ?? WidgetMapUtils.DEFAULT_ZOOM_START
         })), distinctUntilChanged())
             .subscribe((view) => this.map.setView(new View(view)));
         this.fitOption$ = this.options$.pipe(map((options) => !!options.fit), distinctUntilChanged());
@@ -1433,7 +1479,7 @@ class WidgetMapComponent extends DataWidgetComponent {
                     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));
+                        hasRelationLayer.getSource()?.addFeature(WidgetMapUtils.getLinkFeature(relation, source, dest));
                     }
                 });
             }
@@ -1818,10 +1864,10 @@ class WidgetMapComponent extends DataWidgetComponent {
         layer.style = $event.currentTarget?.value;
     }
     export() {
-        exportMapAsImage(this.map, 'map.png');
+        WidgetMapUtils.exportMapAsImage(this.map, 'map.png');
     }
     toImage() {
-        return getMapAsPng(this.map);
+        return WidgetMapUtils.getMapAsPng(this.map);
     }
     changeClustered(layer, $event) {
         layer.clustered = $event;
@@ -2195,5 +2241,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { BACKGROUND_ORDER, CqlUtils, DEFAULT_HEATMAP_RADIUS, DEFAULT_MAP_CENTER, DEFAULT_RADIUS_INTENSITY_FACTOR, DEFAULT_ZOOM_MAX, DEFAULT_ZOOM_MIN, DEFAULT_ZOOM_START, GeometryFieldsForPipe, InteractionManager, PryWidgetMapCssComponent, SelectionInteraction, TOOLTIP_PADDING, WidgetMapComponent, WidgetMapLayerService, WidgetMapLegendUrlPipe, WidgetMapModule, XMLUtils, assignLayersOrder, exportMapAsImage, geometryForLayer, getCircleFeatureFromItem, getFeatureFromItem, getLinkFeature, getMapAsPng, populateIntensityAttribute, populateLocationAttribute };
+export { CqlUtils, GeometryFieldsForPipe, InteractionManager, PryWidgetMapCssComponent, SelectionInteraction, TOOLTIP_PADDING, WidgetMapComponent, WidgetMapLayerService, WidgetMapLegendUrlPipe, WidgetMapModule, WidgetMapUtils, XMLUtils };
 //# sourceMappingURL=provoly-dashboard-widgets-widget-map.mjs.map