@provoly/dashboard 0.11.0

package/esm2022/widgets/widget-map/i18n/en.translations.mjs

@@ -0,0 +1,81 @@
+export const enTranslations = {
+    '@pry': {
+        widget: {
+            map: {
+                attribution: 'Layer credits',
+                attributions: 'Display credits',
+                style: 'Map style',
+                noStyle: 'Empty map',
+                fit: 'Fit data',
+                addLayer: 'Add layer',
+                layer: 'Layer n°{{index}}',
+                layerOptions: 'Layer options',
+                layerTitle: 'Layer Label',
+                layerType: {
+                    title: 'Type',
+                    heatmap: 'Heatmap',
+                    bubble: 'Bubbles map',
+                    relation: 'Links',
+                    marker: 'Markers map',
+                    polygon: 'Shapes map',
+                    wms: 'WMS API',
+                    wmts: 'WMTS API',
+                    featurelayer: 'Feature layer',
+                    vectortile: 'Vector tile',
+                    rastertile: 'Raster tile',
+                    point: 'Points',
+                    line: 'Lines',
+                    geoserver: 'Geoserver',
+                    'multi-line': 'Multi-lines',
+                    'multi-polygon': 'Multi-polygons'
+                },
+                tooltip: {
+                    hover: 'Hover',
+                    click: 'Click',
+                    title: 'Opening tooltips'
+                },
+                tile: 'Tile layer options',
+                locationAttr: 'Placement options',
+                clustering: 'Clustering options',
+                wms: {
+                    url: 'Service Url',
+                    paramLayer: 'Data identifier',
+                    paramTiled: 'Tiled',
+                    style: 'Style',
+                    matrixSet: 'matrixSet'
+                },
+                deleteLayer: 'Delete layer',
+                locationArray: 'Lat and Lng in separate properties',
+                locationAttribute: {
+                    both: 'Location property',
+                    lat: 'Latitude property',
+                    lng: 'Longitude property'
+                },
+                intensityAttribute: 'Intensity property',
+                classes: 'Classes displayed in layer',
+                relations: 'Display links',
+                importStart: 'Import file {{filename}}...',
+                importOk: 'File {{filename}} imported.',
+                importError: 'Cannot read format with extension {{extension}}. Authorized types are {{authorizedFormats}}',
+                importNotFoundInZip: 'No file {{extension}} found in archive.',
+                clustered: 'Clustered',
+                clusterDistance: 'Cluster distance',
+                opacity: 'Opacity',
+                address: 'Address',
+                addressCoords: 'Coordinates',
+                active: 'Active',
+                inactive: 'Inactive',
+                move: 'Move mode',
+                lasso: 'Lasso selection',
+                rectangle: 'Rectangle selection',
+                click: 'Click selection',
+                zoom: 'Zoom selection',
+                export: 'Export map',
+                import: 'Import layer',
+                legend: 'Legend of layer {{layer}}',
+                legendNotProvided: 'Legend not provided by server'
+            }
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/widgets/widget-map/i18n/fr.translations.mjs

@@ -0,0 +1,81 @@
+export const frTranslations = {
+    '@pry': {
+        widget: {
+            map: {
+                attribution: 'Crédits de cette couche',
+                attributions: 'Afficher les crédits',
+                style: 'Style du fond de carte',
+                noStyle: 'Aucun fond de carte',
+                fit: 'Adapter la taille aux données',
+                addLayer: 'Ajouter une couche',
+                layer: 'Couche n°{{index}}',
+                layerOptions: 'Options de la couche',
+                layerTitle: 'Libellé de la couche',
+                layerType: {
+                    title: 'Type',
+                    heatmap: 'Chaleur',
+                    relation: 'Relations',
+                    bubble: 'Bulles',
+                    marker: 'Marqueurs',
+                    polygon: 'Formes',
+                    wms: 'Service WMS',
+                    wmts: 'Service WMTS',
+                    featurelayer: 'Feature layer',
+                    vectortile: 'Vector tile',
+                    rastertile: 'Raster tile',
+                    point: 'Points',
+                    line: 'Lignes',
+                    geoserver: 'Geoserver',
+                    'multi-line': 'Multi-lignes',
+                    'multi-polygon': 'Multi-polygone'
+                },
+                tooltip: {
+                    hover: 'Survol',
+                    click: 'Clic',
+                    title: 'Ouverture des tooltips'
+                },
+                tile: 'Option de couche tuile',
+                locationAttr: 'Options de positionnement',
+                clustering: 'Options de regroupement',
+                wms: {
+                    url: 'Url du service',
+                    paramLayer: 'Identifiant de donnnées',
+                    paramTiled: 'Sous forme de tuiles',
+                    style: 'Style',
+                    matrixSet: 'matrixSet'
+                },
+                deleteLayer: 'Supprimer la couche',
+                locationArray: 'Latitude et Longitude séparées',
+                locationAttribute: {
+                    both: 'Propriété des coordonnées',
+                    lat: 'Propriété de la latitude',
+                    lng: 'Propriété de la longitude'
+                },
+                intensityAttribute: "Propriété de l'intensité",
+                classes: 'Classes affichées dans cette couche',
+                relations: 'Afficher les relations',
+                importStart: 'Importation du fichier {{filename}}...',
+                importOk: 'Fichier {{filename}} importé.',
+                importError: "L'extension {{extension}} n'est pas reconnue. Vous pouvez utiliser: {{authorizedFormats}}.",
+                importNotFoundInZip: "Aucun fichier {{extension}} trouvé dans l'archive.",
+                clustered: 'Regroupement',
+                clusterDistance: 'Distance de regroupement',
+                opacity: 'Opacité',
+                address: 'Adresse',
+                addressCoords: 'Coordonnées',
+                active: 'Active',
+                inactive: 'Inactive',
+                move: 'Mode déplacement',
+                lasso: 'Sélection par lasso',
+                rectangle: 'Sélection par rectangle',
+                click: 'Sélectionner par clic',
+                zoom: 'Zoom par rectangle',
+                export: 'Exporter la carte',
+                import: 'Importer une couche',
+                legend: 'Légende de la couche {{layer}}',
+                legendNotProvided: 'Légende non fournie par le serveur'
+            }
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/widgets/widget-map/interaction/selection-interaction.class.mjs

@@ -0,0 +1,170 @@
+import { DashboardActions, widgetMapConfig } from '@provoly/dashboard';
+import { Feature } from 'ol';
+import { Polygon } from 'ol/geom';
+import PointerInteraction from 'ol/interaction/Pointer';
+import TileLayer from 'ol/layer/Tile';
+import VectorLayer from 'ol/layer/Vector';
+import VectorTileLayer from 'ol/layer/VectorTile';
+import RenderBox from 'ol/render/Box';
+import VectorSource from 'ol/source/Vector';
+import { Fill, Style } from 'ol/style';
+export class SelectionInteraction extends PointerInteraction {
+    constructor() {
+        super({});
+        this.currentRectangle = new RenderBox('ol-rectangle-selection');
+        this.lassoCoordinates = [];
+        this.currentLassoFeature = null;
+        this.actions = [];
+        this.selectionStyle = new Style({
+            fill: new Fill({
+                color: 'rgba(251, 198, 199, 0.5)'
+            })
+        });
+        this.coordinates = null;
+        this.cursor = 'pointer';
+        this.features = [];
+        this.previousCursor = undefined;
+        widgetMapConfig.actions$.subscribe((actions) => {
+            // @ts-ignore
+            this.actions = actions.filter((action) => action !== 'export' && action !== 'upload');
+            this.selectionType = this.actions[0];
+        });
+        this.overlayForLasso = new VectorLayer({
+            source: new VectorSource({
+                useSpatialIndex: false,
+                wrapX: false,
+                features: []
+            }),
+            style: this.selectionStyle,
+            updateWhileInteracting: true
+        });
+    }
+    init(store) {
+        this.store = store;
+        return this;
+    }
+    handleDownEvent(evt) {
+        const map = evt.map;
+        if (this.selectionType === 'move') {
+            return false;
+        }
+        if (this.selectionType === 'click') {
+            this.features = [
+                ...new Set(map
+                    .getFeaturesAtPixel(evt.pixel)
+                    .map((feature) => feature.get('id'))
+                    .filter((id) => !!id))
+            ];
+            // Click and move are collisionning. Need to make another button if needed right now click is aborted
+            return true;
+        }
+        if (['rectangle', 'zoom'].includes(this.selectionType)) {
+            this.coordinates = evt.pixel;
+            this.currentRectangle.setMap(evt.map);
+            this.currentRectangle.setPixels(this.coordinates, this.coordinates);
+        }
+        if (this.selectionType === 'lasso') {
+            this.getMap()?.addLayer(this.overlayForLasso);
+            this.lassoCoordinates = [evt.coordinate];
+            if (!this.currentLassoFeature) {
+                this.currentLassoFeature = new Feature(new Polygon(this.getPolygonCoordinates(this.lassoCoordinates)));
+                this.overlayForLasso.getSource().addFeature(this.currentLassoFeature);
+            }
+        }
+        return true;
+    }
+    getPolygonCoordinates(coordinates) {
+        return [coordinates.concat(coordinates[0])];
+    }
+    handleDragEvent(evt) {
+        if (['rectangle', 'zoom'].includes(this.selectionType)) {
+            this.currentRectangle.setPixels(this.coordinates ?? [0, 0], evt.pixel);
+            return true;
+        }
+        if (this.selectionType === 'lasso') {
+            this.lassoCoordinates.push(evt.coordinate);
+            this.currentLassoFeature?.getGeometry()?.setCoordinates(this.getPolygonCoordinates(this.lassoCoordinates));
+            return true;
+        }
+        return false;
+    }
+    handleUpEvent() {
+        if (this.selectionType === 'click' && this.features.length > 0) {
+            this.store?.dispatch(DashboardActions.selectMany({ ids: this.features }));
+        }
+        if (this.selectionType === 'lasso') {
+            const geometry = this.currentLassoFeature?.getGeometry();
+            const boxFeatures = this.getMap()
+                ?.getAllLayers()
+                .filter((layer) => !(layer instanceof VectorTileLayer) &&
+                !(layer instanceof TileLayer) &&
+                layer?.getSource() instanceof VectorSource)
+                .map((layer) => layer?.getSource()
+                ?.getFeatures()
+                .filter((features) => !!features.get('id'))
+                .filter((feature) => {
+                switch (feature.get('type')) {
+                    case 'point':
+                    case 'marker':
+                        return geometry?.intersectsCoordinate(feature.getGeometry().getCoordinates());
+                    case 'bubble':
+                    case 'line':
+                        return feature
+                            .getGeometry()
+                            .getCoordinates()
+                            .map((coords) => geometry?.intersectsCoordinate(coords))
+                            .reduce((a, b) => a || b, false);
+                    case 'polygon':
+                        return feature
+                            .getGeometry()
+                            .getCoordinates()[0]
+                            .map((coords) => geometry?.intersectsCoordinate(coords))
+                            .reduce((a, b) => a || b, false);
+                    default:
+                        return false;
+                }
+            }))
+                .reduce((p, c) => [...p, ...c], []);
+            const ids = [
+                ...new Set(boxFeatures?.map((feature) => feature.get('id')).filter((id) => !!id))
+            ];
+            this.store?.dispatch(DashboardActions.selectMany({ ids }));
+            this.getMap()?.removeLayer(this.overlayForLasso);
+            this.lassoCoordinates = [];
+        }
+        if (this.selectionType === 'rectangle') {
+            this.currentRectangle.setMap(null);
+            const extent = this.currentRectangle.getGeometry().getExtent();
+            const boxFeatures = this.getMap()
+                ?.getLayers()
+                .getArray()
+                // @ts-ignore
+                .map((layer) => layer.getSource())
+                .map((source) => (source.getFeaturesInExtent ? source.getFeaturesInExtent(extent) : []))
+                .reduce((p, c) => [...p, ...c], [])
+                .filter((feature) => !!feature.getGeometry().intersectsExtent && feature.getGeometry().intersectsExtent(extent));
+            const ids = [
+                ...new Set(boxFeatures.map((feature) => feature.get('id')).filter((id) => !!id))
+            ];
+            this.store?.dispatch(DashboardActions.selectMany({ ids }));
+        }
+        if (this.selectionType === 'zoom') {
+            this.currentRectangle.setMap(null);
+            const extent = this.currentRectangle.getGeometry().getExtent();
+            this.getMap()
+                ?.getView()
+                .fit(extent, { padding: [20, 20, 70, 70], duration: 200 });
+        }
+        if (this.selectionType === 'lasso') {
+            this.getMap()?.removeLayer(this.overlayForLasso);
+        }
+        this.changeSelection(this.actions[0]);
+        this.coordinates = null;
+        this.features = [];
+        return false;
+    }
+    changeSelection(type) {
+        this.selectionType = type;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selection-interaction.class.js","sourceRoot":"","sources":["../../../../../../../projects/provoly/dashboard/widgets/widget-map/interaction/selection-interaction.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { Store } from '@ngrx/store';\nimport { DashboardActions, widgetMapConfig } from '@provoly/dashboard';\nimport { Feature, Map, MapBrowserEvent } from 'ol';\nimport { Coordinate } from 'ol/coordinate';\nimport { Geometry, Polygon } from 'ol/geom';\nimport PointerInteraction from 'ol/interaction/Pointer';\nimport TileLayer from 'ol/layer/Tile';\nimport VectorLayer from 'ol/layer/Vector';\nimport VectorTileLayer from 'ol/layer/VectorTile';\nimport RenderBox from 'ol/render/Box';\nimport VectorSource from 'ol/source/Vector';\nimport { Fill, Style } from 'ol/style';\n\nexport class SelectionInteraction extends PointerInteraction {\n  private coordinates: number[] | null;\n  private cursor: string;\n  private features: string[];\n  private previousCursor: string | undefined;\n  selectionType!: 'click' | 'lasso' | 'rectangle' | 'zoom' | 'move';\n  private store?: Store;\n  private currentRectangle = new RenderBox('ol-rectangle-selection');\n  private overlayForLasso: VectorLayer<any>;\n  private lassoCoordinates: number[][] = [];\n  private currentLassoFeature: Feature<Polygon> | null = null;\n  private actions: ('click' | 'lasso' | 'rectangle' | 'zoom' | 'move')[] = [];\n\n  selectionStyle = new Style({\n    fill: new Fill({\n      color: 'rgba(251, 198, 199, 0.5)'\n    })\n  });\n\n  constructor() {\n    super({});\n\n    this.coordinates = null;\n    this.cursor = 'pointer';\n    this.features = [];\n    this.previousCursor = undefined;\n    widgetMapConfig.actions$.subscribe((actions) => {\n      // @ts-ignore\n      this.actions = actions.filter((action) => action !== 'export' && action !== 'upload');\n      this.selectionType = this.actions[0];\n    });\n    this.overlayForLasso = new VectorLayer({\n      source: new VectorSource({\n        useSpatialIndex: false,\n        wrapX: false,\n        features: []\n      }),\n      style: this.selectionStyle,\n      updateWhileInteracting: true\n    });\n  }\n\n  init(store: Store) {\n    this.store = store;\n    return this;\n  }\n\n  override handleDownEvent(evt: MapBrowserEvent<MouseEvent>) {\n    const map = evt.map;\n\n    if (this.selectionType === 'move') {\n      return false;\n    }\n\n    if (this.selectionType === 'click') {\n      this.features = [\n        ...new Set(\n          map\n            .getFeaturesAtPixel(evt.pixel)\n            .map((feature) => feature.get('id'))\n            .filter((id) => !!id)\n        )\n      ];\n      // Click and move are collisionning. Need to make another button if needed right now click is aborted\n      return true;\n    }\n\n    if (['rectangle', 'zoom'].includes(this.selectionType)) {\n      this.coordinates = evt.pixel;\n      this.currentRectangle.setMap(evt.map);\n      this.currentRectangle.setPixels(this.coordinates, this.coordinates);\n    }\n\n    if (this.selectionType === 'lasso') {\n      this.getMap()?.addLayer(this.overlayForLasso);\n      this.lassoCoordinates = [evt.coordinate];\n      if (!this.currentLassoFeature) {\n        this.currentLassoFeature = new Feature(new Polygon(this.getPolygonCoordinates(this.lassoCoordinates)));\n        this.overlayForLasso.getSource().addFeature(this.currentLassoFeature);\n      }\n    }\n\n    return true;\n  }\n\n  getPolygonCoordinates(coordinates: number[][]) {\n    return [coordinates.concat(coordinates[0])];\n  }\n\n  override handleDragEvent(evt: MapBrowserEvent<MouseEvent>) {\n    if (['rectangle', 'zoom'].includes(this.selectionType)) {\n      this.currentRectangle.setPixels(this.coordinates ?? [0, 0], evt.pixel);\n      return true;\n    }\n    if (this.selectionType === 'lasso') {\n      this.lassoCoordinates.push(evt.coordinate);\n      this.currentLassoFeature?.getGeometry()?.setCoordinates(this.getPolygonCoordinates(this.lassoCoordinates));\n      return true;\n    }\n    return false;\n  }\n\n  override handleUpEvent() {\n    if (this.selectionType === 'click' && this.features.length > 0) {\n      this.store?.dispatch(DashboardActions.selectMany({ ids: this.features }));\n    }\n\n    if (this.selectionType === 'lasso') {\n      const geometry = this.currentLassoFeature?.getGeometry();\n\n      const boxFeatures = this.getMap()\n        ?.getAllLayers()\n        .filter(\n          (layer) =>\n            !(layer instanceof VectorTileLayer) &&\n            !(layer instanceof TileLayer) &&\n            layer?.getSource() instanceof VectorSource\n        )\n        .map(\n          (layer) =>\n            (layer?.getSource() as VectorSource)\n              ?.getFeatures()\n              .filter((features: Feature<any>) => !!features.get('id'))\n              .filter((feature: Feature<any>) => {\n                switch (feature.get('type')) {\n                  case 'point':\n                  case 'marker':\n                    return geometry?.intersectsCoordinate(feature.getGeometry().getCoordinates());\n                  case 'bubble':\n                  case 'line':\n                    return feature\n                      .getGeometry()\n                      .getCoordinates()\n                      .map((coords: Coordinate) => geometry?.intersectsCoordinate(coords))\n                      .reduce((a: boolean, b: boolean) => a || b, false);\n                  case 'polygon':\n                    return feature\n                      .getGeometry()\n                      .getCoordinates()[0]\n                      .map((coords: Coordinate) => geometry?.intersectsCoordinate(coords))\n                      .reduce((a: boolean, b: boolean) => a || b, false);\n                  default:\n                    return false;\n                }\n              })\n        )\n        .reduce((p, c) => [...p, ...c], []);\n\n      const ids = [\n        ...new Set(\n          boxFeatures?.map((feature: Feature<Geometry>) => feature.get('id') as string).filter((id: string) => !!id)\n        )\n      ] as string[];\n\n      this.store?.dispatch(DashboardActions.selectMany({ ids }));\n\n      this.getMap()?.removeLayer(this.overlayForLasso);\n      this.lassoCoordinates = [];\n    }\n\n    if (this.selectionType === 'rectangle') {\n      this.currentRectangle.setMap(null as unknown as Map);\n\n      const extent = this.currentRectangle.getGeometry().getExtent();\n      const boxFeatures = this.getMap()\n        ?.getLayers()\n        .getArray()\n        // @ts-ignore\n        .map((layer) => layer.getSource())\n        .map((source) => (source.getFeaturesInExtent ? source.getFeaturesInExtent(extent) : []))\n        .reduce((p, c) => [...p, ...c], [])\n        .filter(\n          (feature: any) => !!feature.getGeometry().intersectsExtent && feature.getGeometry().intersectsExtent(extent)\n        );\n\n      const ids = [\n        ...new Set(\n          boxFeatures.map((feature: Feature<Geometry>) => feature.get('id') as string).filter((id: string) => !!id)\n        )\n      ] as string[];\n\n      this.store?.dispatch(DashboardActions.selectMany({ ids }));\n    }\n\n    if (this.selectionType === 'zoom') {\n      this.currentRectangle.setMap(null as unknown as Map);\n\n      const extent = this.currentRectangle.getGeometry().getExtent();\n      this.getMap()\n        ?.getView()\n        .fit(extent, { padding: [20, 20, 70, 70], duration: 200 });\n    }\n\n    if (this.selectionType === 'lasso') {\n      this.getMap()?.removeLayer(this.overlayForLasso);\n    }\n\n    this.changeSelection(this.actions[0]);\n    this.coordinates = null;\n    this.features = [];\n\n    return false;\n  }\n\n  changeSelection(type: string) {\n    this.selectionType = type as 'click' | 'lasso' | 'rectangle' | 'zoom' | 'move';\n  }\n}\n"]}

package/esm2022/widgets/widget-map/pipe/widget-map-geometry-fields-for.pipe.mjs

@@ -0,0 +1,52 @@
+import { Pipe } from '@angular/core';
+import { ClassSelectors, FieldSelectors } from '@provoly/dashboard';
+import { combineLatest, filter, map } from 'rxjs';
+import { geometryForLayer } from '../utils/widget-map.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+export class GeometryFieldsForPipe {
+    constructor(store) {
+        this.store = store;
+        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);
+    }
+    transform(value, ...args) {
+        const specificLayer = value;
+        const limitToClasses = args[0].classes;
+        const type = 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)
+                .filter((oClassId) => !specificLayer.classes ||
+                specificLayer.classes.length === 0 ||
+                !!specificLayer.classes?.find((cl) => oClassId === cl))
+                .filter((classId) => !limitToClasses || limitToClasses.length === 0 || limitToClasses.includes(classId))
+                .map((oClassId) => classes.find((cl) => cl.id === oClassId) ?? { attributes: [] })
+                .map((oClass) => oClass.attributes)
+                .reduce((prev, curr) => [...prev, ...curr], [])
+                .filter((attr) => {
+                const attrField = fields.find((f) => f.id === attr.field);
+                return !!attrField && attrField.type === type;
+            })
+                .sort((a, b) => a.name.localeCompare(b.name));
+            const resArr = [];
+            potentialFields.forEach(function (attr) {
+                if (resArr.findIndex((x) => x.name == attr.name) <= -1) {
+                    resArr.push(attr);
+                }
+            });
+            return resArr;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: GeometryFieldsForPipe, deps: [{ token: i1.Store }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.1.6", ngImport: i0, type: GeometryFieldsForPipe, name: "geometryFieldsFor" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: GeometryFieldsForPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'geometryFieldsFor'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/widgets/widget-map/pipe/widget-map-legend-url.pipe.mjs

@@ -0,0 +1,22 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class WidgetMapLegendUrlPipe {
+    transform(geoLayer) {
+        if (geoLayer && geoLayer.url) {
+            const layerUrlWithQmark = geoLayer.url.indexOf('?') === -1 ? geoLayer.url + '?' : geoLayer.url;
+            const layerUrlWithService = layerUrlWithQmark.indexOf('&SERVICE=') === -1 ? layerUrlWithQmark + '&SERVICE=WMS' : layerUrlWithQmark;
+            const layerUrlWithVersion = layerUrlWithService.indexOf('&VERSION=') === -1 ? layerUrlWithService + '&VERSION=1.3.0' : layerUrlWithService;
+            return `${layerUrlWithVersion}&REQUEST=GetLegendGraphic&format=image%2Fpng&LAYER=${geoLayer.paramLayer}&LEGEND_OPTIONS=fontName:Ubuntu`;
+        }
+        return '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: WidgetMapLegendUrlPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.1.6", ngImport: i0, type: WidgetMapLegendUrlPipe, name: "legendUrl" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImport: i0, type: WidgetMapLegendUrlPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'legendUrl'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdm9seS1kYXNoYm9hcmQtd2lkZ2V0cy13aWRnZXQtbWFwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvcHJvdm9seS9kYXNoYm9hcmQvd2lkZ2V0cy93aWRnZXQtbWFwL3Byb3ZvbHktZGFzaGJvYXJkLXdpZGdldHMtd2lkZ2V0LW1hcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/widgets/widget-map/public-api.mjs

@@ -0,0 +1,7 @@
+export * from './widget-map.module';
+export * from './component/widget-map.component';
+export * from './component/widget-map-layer.service';
+export * from './pipe/widget-map-geometry-fields-for.pipe';
+export * from './pipe/widget-map-legend-url.pipe';
+export * from './utils/widget-map.utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3Byb3ZvbHkvZGFzaGJvYXJkL3dpZGdldHMvd2lkZ2V0LW1hcC9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsNENBQTRDLENBQUM7QUFDM0QsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi93aWRnZXQtbWFwLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudC93aWRnZXQtbWFwLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudC93aWRnZXQtbWFwLWxheWVyLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9waXBlL3dpZGdldC1tYXAtZ2VvbWV0cnktZmllbGRzLWZvci5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vcGlwZS93aWRnZXQtbWFwLWxlZ2VuZC11cmwucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxzL3dpZGdldC1tYXAudXRpbHMnO1xuIl19

package/esm2022/widgets/widget-map/reader/kmz-zip-reader.class.mjs

@@ -0,0 +1,57 @@
+import JSZip from 'jszip';
+import { KML } from 'ol/format';
+import VectorLayer from 'ol/layer/Vector';
+import VectorSource from 'ol/source/Vector';
+export class KmzZipReader {
+    constructor() {
+        this.reader = new JSZip();
+        this.fileInsideZipExtension = '.kml';
+        this.parser = new KML();
+    }
+    withMap(map) {
+        this.map = map;
+        return this;
+    }
+    apply(file, resolve, reject) {
+        this.reader.loadAsync(file).then((zip) => {
+            let entry = null;
+            let imageReplacements = [];
+            zip.forEach((path, zipEntry) => {
+                if (zipEntry.name.endsWith(this.fileInsideZipExtension)) {
+                    entry = zipEntry;
+                }
+                const split = zipEntry.name.toLowerCase().split('.');
+                const extention = split[split.length - 1];
+                if (['png', 'jpeg'].includes(extention)) {
+                    imageReplacements.push(new Promise((resolveS) => {
+                        zipEntry.async('arraybuffer').then((buffer) => {
+                            resolveS({
+                                name: zipEntry.name,
+                                image: window.URL.createObjectURL(new Blob([buffer], { type: `image/${extention}` }))
+                            });
+                        });
+                    }));
+                }
+            });
+            if (entry === null) {
+                reject({ msg: '@pry.widget.map.importNotFoundInZip', val: { extension: this.fileInsideZipExtension } });
+            }
+            else {
+                Promise.all(imageReplacements).then((replacements) => {
+                    entry?.async('string').then((buffer) => {
+                        let replacedBuffer = buffer;
+                        replacements.forEach((replacement) => (replacedBuffer = replacedBuffer.replace(replacement.name, replacement.image)));
+                        resolve(new VectorLayer({
+                            source: new VectorSource({
+                                features: this.parser.readFeatures(replacedBuffer, {
+                                    featureProjection: this.map.getView().getProjection()
+                                })
+                            })
+                        }));
+                    });
+                });
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/widgets/widget-map/reader/map-formats-reader.class.mjs

@@ -0,0 +1,37 @@
+import { GeoJSON, GPX, IGC, KML, TopoJSON } from 'ol/format';
+import { KmzZipReader } from './kmz-zip-reader.class';
+import { ReadAsText } from './read-as-text.class';
+import { ShpZipReader } from './shp-zip-reader.class';
+export class MapFormatsReader {
+    constructor(map) {
+        this.formats = {
+            gpx: new ReadAsText(new GPX()),
+            geojson: new ReadAsText(new GeoJSON()),
+            igc: new ReadAsText(new IGC()),
+            kml: new ReadAsText(new KML()),
+            kmz: new KmzZipReader(),
+            'kml.zip': new KmzZipReader(),
+            topojson: new ReadAsText(new TopoJSON()),
+            'shp.zip': new ShpZipReader()
+        };
+        this.map = map;
+    }
+    decodeFile(file) {
+        return new Promise((resolve, reject) => {
+            const split = file.name.split('.');
+            let extension = split[split.length - 1];
+            if (extension === 'zip') {
+                extension = `${split[split.length - 2]}.${split[split.length - 1]}`;
+            }
+            if (!this.formats[extension]) {
+                reject({
+                    msg: '@pry.widget.map.importError',
+                    val: { extension, authorizedFormats: Object.keys(this.formats).join(', ') }
+                });
+                return;
+            }
+            this.formats[extension].withMap(this.map).apply(file, resolve, reject);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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