@igo2/integration 1.15.4 → 16.0.0-rc.0

package/esm2022/lib/map/map-proximity.state.mjs

@@ -0,0 +1,180 @@
+import { Injectable } from '@angular/core';
+import { FeatureStore, featureFromOl, measureOlGeometryLength, FEATURE, roundCoordTo } from '@igo2/geo';
+import { BehaviorSubject, combineLatest, interval } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
+import { MapState } from '../map/map.state';
+import GeoJSON from 'ol/format/GeoJSON';
+import { uuid } from '@igo2/utils';
+import olLayerVector from 'ol/layer/Vector';
+import olLineString from 'ol/geom/LineString';
+import * as olProj from 'ol/proj';
+import { StorageService } from '@igo2/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../map/map.state";
+import * as i2 from "@igo2/core";
+/**
+ * Service that holds the state of the direction module
+ */
+export class MapProximityState {
+    mapState;
+    storageService;
+    defaultProximityRadiusValue = 30;
+    enabled$ = new BehaviorSubject(false);
+    proximityRadiusValue$;
+    proximitylocationType$ = new BehaviorSubject('geolocation');
+    proximityFeatureStore;
+    subs$$ = [];
+    currentPositionCoordinate$ = new BehaviorSubject(undefined);
+    get map() {
+        return this.mapState.map;
+    }
+    constructor(mapState, storageService) {
+        this.mapState = mapState;
+        this.storageService = storageService;
+        this.proximityFeatureStore = new FeatureStore([], {
+            map: this.mapState.map
+        });
+        this.proximityRadiusValue$ = new BehaviorSubject(this.storageService.get('mapProximityRadius') ||
+            this.defaultProximityRadiusValue);
+        this.mapState.map.ol.once('rendercomplete', () => {
+            this.subscribeProximityMonitor();
+        });
+    }
+    subscribeProximityMonitor() {
+        this.subs$$.push(combineLatest([
+            this.enabled$,
+            this.proximitylocationType$,
+            this.proximityRadiusValue$,
+            interval(5000),
+            this.map.geolocationController.position$
+        ])
+            .pipe(debounceTime(750))
+            .subscribe((bunch) => {
+            this.proximityFeatureStore.clear();
+            const enabled = bunch[0];
+            const layers = this.map.layers;
+            const currentPos = this.map.geolocationController.position$.value;
+            const locationType = bunch[1];
+            const proximityRadiusValue = bunch[2];
+            this.storageService.set('mapProximityRadius', proximityRadiusValue || this.defaultProximityRadiusValue);
+            if (!enabled) {
+                return;
+            }
+            let coord;
+            if (locationType === 'geolocation') {
+                if (!currentPos || !currentPos.position) {
+                    return;
+                }
+                coord = olProj.transform(currentPos.position, currentPos.projection, this.map.projection);
+                this.map.mapCenter$.next(false);
+            }
+            else {
+                coord = this.map.viewController.getCenter();
+                this.map.mapCenter$.next(true);
+            }
+            const coordLonLat = olProj.transform(coord, this.map.projection, 'EPSG:4269');
+            const roundedCoordLonLat = roundCoordTo(coordLonLat, 6);
+            this.currentPositionCoordinate$.next(roundedCoordLonLat);
+            const layersToMonitor = layers.filter((layer) => layer.ol instanceof olLayerVector &&
+                layer.dataSource.options.queryable &&
+                layer.visible &&
+                layer.isInResolutionsRange);
+            layersToMonitor.map((layerToMonitor) => {
+                const layerSource = layerToMonitor.ol.getSource();
+                // Mostly for polygon features.
+                const olFeaturesAtCoordinate = layerSource.getFeaturesAtCoordinate(coord);
+                if (olFeaturesAtCoordinate && olFeaturesAtCoordinate.length) {
+                    olFeaturesAtCoordinate.map((olFeatureAtCoordinate) => {
+                        const featureAtThisPosition = featureFromOl(olFeatureAtCoordinate, this.map.projection);
+                        let title = this.getQueryTitle(featureAtThisPosition, layerToMonitor);
+                        // todo handle imported layers without querytitle? prompt title or detect first column?
+                        this.addFeatureToStore(layerToMonitor, coord, featureAtThisPosition, title, 0);
+                    });
+                }
+                else {
+                    // compute proximity for remaining sources
+                    const closestOlFeature = layerSource.getClosestFeatureToCoordinate(coord);
+                    if (closestOlFeature) {
+                        const closestOlGeom = closestOlFeature.getGeometry();
+                        const closestFeature = featureFromOl(closestOlFeature, this.map.projection);
+                        const geometryClosestPoint = closestOlGeom.getClosestPoint(coord);
+                        const linebetween = new olLineString([
+                            coord,
+                            geometryClosestPoint
+                        ]);
+                        const lineLength = measureOlGeometryLength(linebetween, 'EPSG:3857');
+                        if (lineLength <= proximityRadiusValue) {
+                            let title = this.getQueryTitle(closestFeature, layerToMonitor);
+                            // todo handle imported layers without querytitle? prompt title or detect first column?
+                            this.addFeatureToStore(layerToMonitor, coord, closestFeature, title, lineLength);
+                        }
+                    }
+                }
+            });
+        }));
+    }
+    /**
+     * Add a feature with proximity properties to the store
+     * @internal
+     */
+    addFeatureToStore(layer, coordFromCalculatedDistance, feature, title, distance) {
+        const featureId = uuid();
+        const projection = this.map.ol.getView().getProjection();
+        const olGeometry = feature.ol.getGeometry();
+        const geometry = new GeoJSON().writeGeometryObject(olGeometry, {
+            featureProjection: projection,
+            dataProjection: projection
+        });
+        this.proximityFeatureStore.update({
+            type: FEATURE,
+            geometry,
+            projection: projection.getCode(),
+            properties: {
+                ...feature.properties,
+                ...{
+                    id: featureId,
+                    element: title,
+                    distance,
+                    coordFromCalculatedDistance,
+                    layerSrcId: layer.id,
+                    layerSrcTitle: layer.title
+                }
+            },
+            meta: {
+                id: featureId
+            }
+        });
+    }
+    getQueryTitle(feature, layer) {
+        let title;
+        if (layer.options?.source?.options) {
+            const dataSourceOptions = layer.options.source
+                .options;
+            if (dataSourceOptions.queryTitle) {
+                title = this.getLabelMatch(feature, dataSourceOptions.queryTitle);
+            }
+        }
+        return title;
+    }
+    getLabelMatch(feature, labelMatch) {
+        let label = labelMatch;
+        const labelToGet = Array.from(labelMatch.matchAll(/\$\{([^\{\}]+)\}/g));
+        labelToGet.forEach((v) => {
+            label = label.replace(v[0], feature.properties[v[1]]);
+        });
+        // Nothing done? check feature's attribute
+        if (labelToGet.length === 0 && label === labelMatch) {
+            label = feature.properties[labelMatch] || labelMatch;
+        }
+        return label;
+    }
+    static ɵfac = function MapProximityState_Factory(t) { return new (t || MapProximityState)(i0.ɵɵinject(i1.MapState), i0.ɵɵinject(i2.StorageService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: MapProximityState, factory: MapProximityState.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MapProximityState, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.MapState }, { type: i2.StorageService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map-proximity.state.js","sourceRoot":"","sources":["../../../../../packages/integration/src/lib/map/map-proximity.state.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\n\r\nimport {\r\n  FeatureStore,\r\n  Feature,\r\n  IgoMap,\r\n  featureFromOl,\r\n  measureOlGeometryLength,\r\n  Layer,\r\n  QueryableDataSourceOptions,\r\n  FEATURE,\r\n  roundCoordTo,\r\n  QueryableDataSource,\r\n  MapGeolocationState\r\n} from '@igo2/geo';\r\nimport { BehaviorSubject, combineLatest, interval, Subscription } from 'rxjs';\r\nimport { debounceTime } from 'rxjs/operators';\r\nimport { MapState } from '../map/map.state';\r\n\r\nimport GeoJSON from 'ol/format/GeoJSON';\r\nimport { uuid } from '@igo2/utils';\r\n\r\nimport olLayerVector from 'ol/layer/Vector';\r\nimport olVectorSource from 'ol/source/Vector';\r\nimport Geometry from 'ol/geom/Geometry';\r\nimport olLineString from 'ol/geom/LineString';\r\nimport * as olProj from 'ol/proj';\r\nimport { StorageService } from '@igo2/core';\r\n/**\r\n * Service that holds the state of the direction module\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class MapProximityState {\r\n  private defaultProximityRadiusValue: number = 30;\r\n\r\n  public enabled$: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(\r\n    false\r\n  );\r\n  public proximityRadiusValue$: BehaviorSubject<number>;\r\n  public proximitylocationType$: BehaviorSubject<string> =\r\n    new BehaviorSubject<string>('geolocation');\r\n  public proximityFeatureStore: FeatureStore<Feature>;\r\n  private subs$$: Subscription[] = [];\r\n  public currentPositionCoordinate$: BehaviorSubject<[number, number]> =\r\n    new BehaviorSubject(undefined);\r\n\r\n  get map(): IgoMap {\r\n    return this.mapState.map;\r\n  }\r\n\r\n  constructor(\r\n    private mapState: MapState,\r\n    private storageService: StorageService\r\n  ) {\r\n    this.proximityFeatureStore = new FeatureStore<Feature>([], {\r\n      map: this.mapState.map\r\n    });\r\n\r\n    this.proximityRadiusValue$ = new BehaviorSubject<number>(\r\n      (this.storageService.get('mapProximityRadius') as number) ||\r\n        this.defaultProximityRadiusValue\r\n    );\r\n\r\n    this.mapState.map.ol.once('rendercomplete', () => {\r\n      this.subscribeProximityMonitor();\r\n    });\r\n  }\r\n\r\n  subscribeProximityMonitor() {\r\n    this.subs$$.push(\r\n      combineLatest([\r\n        this.enabled$,\r\n        this.proximitylocationType$,\r\n        this.proximityRadiusValue$,\r\n        interval(5000),\r\n        this.map.geolocationController.position$\r\n      ])\r\n        .pipe(debounceTime(750))\r\n        .subscribe(\r\n          (bunch: [boolean, string, number, number, MapGeolocationState]) => {\r\n            this.proximityFeatureStore.clear();\r\n            const enabled = bunch[0];\r\n            const layers = this.map.layers;\r\n            const currentPos = this.map.geolocationController.position$.value;\r\n            const locationType = bunch[1];\r\n            const proximityRadiusValue = bunch[2];\r\n            this.storageService.set(\r\n              'mapProximityRadius',\r\n              proximityRadiusValue || this.defaultProximityRadiusValue\r\n            );\r\n\r\n            if (!enabled) {\r\n              return;\r\n            }\r\n\r\n            let coord: number[];\r\n            if (locationType === 'geolocation') {\r\n              if (!currentPos || !currentPos.position) {\r\n                return;\r\n              }\r\n\r\n              coord = olProj.transform(\r\n                currentPos.position,\r\n                currentPos.projection,\r\n                this.map.projection\r\n              );\r\n              this.map.mapCenter$.next(false);\r\n            } else {\r\n              coord = this.map.viewController.getCenter();\r\n              this.map.mapCenter$.next(true);\r\n            }\r\n\r\n            const coordLonLat = olProj.transform(\r\n              coord,\r\n              this.map.projection,\r\n              'EPSG:4269'\r\n            );\r\n            const roundedCoordLonLat = roundCoordTo(\r\n              coordLonLat as [number, number],\r\n              6\r\n            );\r\n            this.currentPositionCoordinate$.next(roundedCoordLonLat);\r\n\r\n            const layersToMonitor = layers.filter(\r\n              (layer) =>\r\n                layer.ol instanceof olLayerVector &&\r\n                (layer.dataSource as QueryableDataSource).options.queryable &&\r\n                layer.visible &&\r\n                layer.isInResolutionsRange\r\n            );\r\n\r\n            layersToMonitor.map((layerToMonitor) => {\r\n              const layerSource =\r\n                layerToMonitor.ol.getSource() as olVectorSource<Geometry>;\r\n\r\n              // Mostly for polygon features.\r\n              const olFeaturesAtCoordinate =\r\n                layerSource.getFeaturesAtCoordinate(coord);\r\n              if (olFeaturesAtCoordinate && olFeaturesAtCoordinate.length) {\r\n                olFeaturesAtCoordinate.map((olFeatureAtCoordinate) => {\r\n                  const featureAtThisPosition = featureFromOl(\r\n                    olFeatureAtCoordinate,\r\n                    this.map.projection\r\n                  );\r\n                  let title = this.getQueryTitle(\r\n                    featureAtThisPosition,\r\n                    layerToMonitor\r\n                  );\r\n                  // todo handle imported layers without querytitle? prompt title or detect first column?\r\n                  this.addFeatureToStore(\r\n                    layerToMonitor,\r\n                    coord,\r\n                    featureAtThisPosition,\r\n                    title,\r\n                    0\r\n                  );\r\n                });\r\n              } else {\r\n                // compute proximity for remaining sources\r\n                const closestOlFeature =\r\n                  layerSource.getClosestFeatureToCoordinate(coord);\r\n                if (closestOlFeature) {\r\n                  const closestOlGeom = closestOlFeature.getGeometry();\r\n                  const closestFeature = featureFromOl(\r\n                    closestOlFeature,\r\n                    this.map.projection\r\n                  );\r\n                  const geometryClosestPoint =\r\n                    closestOlGeom.getClosestPoint(coord);\r\n                  const linebetween = new olLineString([\r\n                    coord,\r\n                    geometryClosestPoint\r\n                  ]);\r\n                  const lineLength = measureOlGeometryLength(\r\n                    linebetween,\r\n                    'EPSG:3857'\r\n                  );\r\n                  if (lineLength <= proximityRadiusValue) {\r\n                    let title = this.getQueryTitle(\r\n                      closestFeature,\r\n                      layerToMonitor\r\n                    );\r\n                    // todo handle imported layers without querytitle? prompt title or detect first column?\r\n                    this.addFeatureToStore(\r\n                      layerToMonitor,\r\n                      coord,\r\n                      closestFeature,\r\n                      title,\r\n                      lineLength\r\n                    );\r\n                  }\r\n                }\r\n              }\r\n            });\r\n          }\r\n        )\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Add a feature with proximity properties to the store\r\n   * @internal\r\n   */\r\n  private addFeatureToStore(\r\n    layer: Layer,\r\n    coordFromCalculatedDistance,\r\n    feature: Feature,\r\n    title,\r\n    distance\r\n  ) {\r\n    const featureId = uuid();\r\n    const projection = this.map.ol.getView().getProjection();\r\n    const olGeometry = feature.ol.getGeometry() as Geometry;\r\n    const geometry = new GeoJSON().writeGeometryObject(olGeometry, {\r\n      featureProjection: projection,\r\n      dataProjection: projection\r\n    }) as any;\r\n    this.proximityFeatureStore.update({\r\n      type: FEATURE,\r\n      geometry,\r\n      projection: projection.getCode(),\r\n      properties: {\r\n        ...feature.properties,\r\n        ...{\r\n          id: featureId,\r\n          element: title,\r\n          distance,\r\n          coordFromCalculatedDistance,\r\n          layerSrcId: layer.id,\r\n          layerSrcTitle: layer.title\r\n        }\r\n      },\r\n      meta: {\r\n        id: featureId\r\n      }\r\n    });\r\n  }\r\n\r\n  getQueryTitle(feature: Feature, layer: Layer): string {\r\n    let title;\r\n    if (layer.options?.source?.options) {\r\n      const dataSourceOptions = layer.options.source\r\n        .options as QueryableDataSourceOptions;\r\n      if (dataSourceOptions.queryTitle) {\r\n        title = this.getLabelMatch(feature, dataSourceOptions.queryTitle);\r\n      }\r\n    }\r\n    return title;\r\n  }\r\n\r\n  getLabelMatch(feature: Feature, labelMatch): string {\r\n    let label = labelMatch;\r\n    const labelToGet = Array.from(labelMatch.matchAll(/\\$\\{([^\\{\\}]+)\\}/g));\r\n\r\n    labelToGet.forEach((v) => {\r\n      label = label.replace(v[0], feature.properties[v[1]]);\r\n    });\r\n\r\n    // Nothing done? check feature's attribute\r\n    if (labelToGet.length === 0 && label === labelMatch) {\r\n      label = feature.properties[labelMatch] || labelMatch;\r\n    }\r\n    return label;\r\n  }\r\n}\r\n"]}

package/{esm2020 → esm2022}/lib/map/map-tool/index.mjs

@@ -1,2 +1,2 @@
-export * from './map-tool.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9pbnRlZ3JhdGlvbi9zcmMvbGliL21hcC9tYXAtdG9vbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9tYXAtdG9vbC5jb21wb25lbnQnO1xyXG4iXX0=
+export * from './map-tool.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9pbnRlZ3JhdGlvbi9zcmMvbGliL21hcC9tYXAtdG9vbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9tYXAtdG9vbC5jb21wb25lbnQnO1xuIl19

package/esm2022/lib/map/map-tool/map-tool.component.mjs

@@ -0,0 +1,140 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, ChangeDetectionStrategy, Input } from '@angular/core';
+import { ToolComponent } from '@igo2/common';
+import { LayerListControlsEnum } from '@igo2/geo';
+import { MapState } from './../map.state';
+import { ImportExportMode, ImportExportState } from '../../import-export/import-export.state';
+import { ToolState } from '../../tool/tool.state';
+import * as i0 from "@angular/core";
+import * as i1 from "./../map.state";
+import * as i2 from "../../tool/tool.state";
+import * as i3 from "../../import-export/import-export.state";
+import * as i4 from "@angular/material/tabs";
+import * as i5 from "@igo2/geo";
+import * as i6 from "@igo2/context";
+import * as i7 from "../../workspace/workspace-button/workspace-button.component";
+import * as i8 from "@ngx-translate/core";
+function MapToolComponent_ng_template_4_Template(rf, ctx) { if (rf & 1) {
+    const _r4 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelement(0, "igo-workspace-button", 4);
+    i0.ɵɵelementStart(1, "igo-export-button", 5);
+    i0.ɵɵlistener("click", function MapToolComponent_ng_template_4_Template_igo_export_button_click_1_listener() { const restoredCtx = i0.ɵɵrestoreView(_r4); const layer_r2 = restoredCtx.layer; const ctx_r3 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r3.activateExport(layer_r2)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelement(2, "igo-ogc-filter-button", 6)(3, "igo-time-filter-button", 6)(4, "igo-track-feature-button", 7)(5, "igo-metadata-button", 4);
+} if (rf & 2) {
+    const layer_r2 = ctx.layer;
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("layer", layer_r2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("layer", layer_r2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("header", ctx_r1.ogcButton)("layer", layer_r2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("header", ctx_r1.timeButton)("layer", layer_r2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("trackFeature", true)("layer", layer_r2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("layer", layer_r2);
+} }
+/**
+ * Tool to browse a map's layers or to choose a different map
+ */
+export let MapToolComponent = class MapToolComponent {
+    mapState;
+    toolState;
+    importExportState;
+    toggleLegendOnVisibilityChange = false;
+    expandLegendOfVisibleLayers = false;
+    updateLegendOnResolutionChange = false;
+    ogcButton = true;
+    timeButton = true;
+    layerListControls = {};
+    queryBadge = false;
+    get map() {
+        return this.mapState.map;
+    }
+    get excludeBaseLayers() {
+        return this.layerListControls.excludeBaseLayers || false;
+    }
+    get layerFilterAndSortOptions() {
+        const filterSortOptions = Object.assign({
+            showToolbar: LayerListControlsEnum.default
+        }, this.layerListControls);
+        switch (this.layerListControls.showToolbar) {
+            case LayerListControlsEnum.always:
+                filterSortOptions.showToolbar = LayerListControlsEnum.always;
+                break;
+            case LayerListControlsEnum.never:
+                filterSortOptions.showToolbar = LayerListControlsEnum.never;
+                break;
+            default:
+                break;
+        }
+        return filterSortOptions;
+    }
+    constructor(mapState, toolState, importExportState) {
+        this.mapState = mapState;
+        this.toolState = toolState;
+        this.importExportState = importExportState;
+    }
+    activateExport(layer) {
+        let id = layer.id;
+        if (layer.options.workspace?.workspaceId) {
+            id =
+                layer.options.workspace.workspaceId !== layer.id
+                    ? layer.options.workspace.workspaceId
+                    : layer.id;
+        }
+        this.importExportState.setsExportOptions({ layers: [id] });
+        this.importExportState.setMode(ImportExportMode.export);
+        this.toolState.toolbox.activateTool('importExport');
+    }
+    static ɵfac = function MapToolComponent_Factory(t) { return new (t || MapToolComponent)(i0.ɵɵdirectiveInject(i1.MapState), i0.ɵɵdirectiveInject(i2.ToolState), i0.ɵɵdirectiveInject(i3.ImportExportState)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: MapToolComponent, selectors: [["igo-map-tool"]], inputs: { toggleLegendOnVisibilityChange: "toggleLegendOnVisibilityChange", expandLegendOfVisibleLayers: "expandLegendOfVisibleLayers", updateLegendOnResolutionChange: "updateLegendOnResolutionChange", ogcButton: "ogcButton", timeButton: "timeButton", layerListControls: "layerListControls", queryBadge: "queryBadge" }, decls: 9, vars: 14, consts: [[3, "label"], ["igoLayerListBinding", "", 3, "map", "excludeBaseLayers", "layerFilterAndSortOptions", "expandLegendOfVisibleLayers", "toggleLegendOnVisibilityChange", "updateLegendOnResolutionChange", "floatLabel", "queryBadge"], ["igoLayerItemToolbar", ""], ["igoContextListBinding", ""], [3, "layer"], [3, "layer", "click"], [3, "header", "layer"], [3, "trackFeature", "layer"]], template: function MapToolComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "mat-tab-group")(1, "mat-tab", 0);
+            i0.ɵɵpipe(2, "translate");
+            i0.ɵɵelementStart(3, "igo-layer-list", 1);
+            i0.ɵɵtemplate(4, MapToolComponent_ng_template_4_Template, 6, 9, "ng-template", null, 2, i0.ɵɵtemplateRefExtractor);
+            i0.ɵɵelementEnd()();
+            i0.ɵɵelementStart(6, "mat-tab", 0);
+            i0.ɵɵpipe(7, "translate");
+            i0.ɵɵelement(8, "igo-context-list", 3);
+            i0.ɵɵelementEnd()();
+        } if (rf & 2) {
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("label", i0.ɵɵpipeBind1(2, 10, "igo.integration.tools.map"));
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("map", ctx.map)("excludeBaseLayers", ctx.excludeBaseLayers)("layerFilterAndSortOptions", ctx.layerFilterAndSortOptions)("expandLegendOfVisibleLayers", ctx.expandLegendOfVisibleLayers)("toggleLegendOnVisibilityChange", ctx.toggleLegendOnVisibilityChange)("updateLegendOnResolutionChange", ctx.updateLegendOnResolutionChange)("floatLabel", false)("queryBadge", ctx.queryBadge);
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("label", i0.ɵɵpipeBind1(7, 12, "igo.integration.tools.contexts"));
+        } }, dependencies: [i4.MatTab, i4.MatTabGroup, i5.LayerListComponent, i5.LayerListBindingDirective, i5.TrackFeatureButtonComponent, i5.MetadataButtonComponent, i5.ExportButtonComponent, i5.TimeFilterButtonComponent, i5.OgcFilterButtonComponent, i6.ContextListComponent, i6.ContextListBindingDirective, i7.WorkspaceButtonComponent, i8.TranslatePipe], styles: ["[_nghost-%COMP%]     .mat-mdc-tab-body-content{overflow:hidden}"], changeDetection: 0 });
+};
+MapToolComponent = __decorate([
+    ToolComponent({
+        name: 'map',
+        title: 'igo.integration.tools.map',
+        icon: 'map'
+    }),
+    __metadata("design:paramtypes", [MapState,
+        ToolState,
+        ImportExportState])
+], MapToolComponent);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MapToolComponent, [{
+        type: Component,
+        args: [{ selector: 'igo-map-tool', changeDetection: ChangeDetectionStrategy.OnPush, template: "<mat-tab-group>\r\n  <mat-tab [label]=\"'igo.integration.tools.map' | translate\">\r\n    <igo-layer-list\r\n      [map]=\"map\"\r\n      igoLayerListBinding\r\n      [excludeBaseLayers]=\"excludeBaseLayers\"\r\n      [layerFilterAndSortOptions]=\"layerFilterAndSortOptions\"\r\n      [expandLegendOfVisibleLayers]=\"expandLegendOfVisibleLayers\"\r\n      [toggleLegendOnVisibilityChange]=\"toggleLegendOnVisibilityChange\"\r\n      [updateLegendOnResolutionChange]=\"updateLegendOnResolutionChange\"\r\n      [floatLabel]=\"false\"\r\n      [queryBadge]=\"queryBadge\"\r\n    >\r\n      <ng-template #igoLayerItemToolbar let-layer=\"layer\">\r\n        <!-- <igo-download-button [layer]=\"layer\"></igo-download-button> -->\r\n        <igo-workspace-button [layer]=\"layer\"></igo-workspace-button>\r\n        <igo-export-button\r\n          [layer]=\"layer\"\r\n          (click)=\"activateExport(layer)\"\r\n        ></igo-export-button>\r\n        <igo-ogc-filter-button\r\n          [header]=\"ogcButton\"\r\n          [layer]=\"layer\"\r\n        ></igo-ogc-filter-button>\r\n        <igo-time-filter-button\r\n          [header]=\"timeButton\"\r\n          [layer]=\"layer\"\r\n        ></igo-time-filter-button>\r\n        <igo-track-feature-button\r\n          [trackFeature]=\"true\"\r\n          [layer]=\"layer\"\r\n        ></igo-track-feature-button>\r\n        <igo-metadata-button [layer]=\"layer\"></igo-metadata-button>\r\n      </ng-template>\r\n    </igo-layer-list>\r\n  </mat-tab>\r\n\r\n  <mat-tab [label]=\"'igo.integration.tools.contexts' | translate\">\r\n    <igo-context-list igoContextListBinding></igo-context-list>\r\n  </mat-tab>\r\n</mat-tab-group>\r\n", styles: [":host ::ng-deep .mat-mdc-tab-body-content{overflow:hidden}\n"] }]
+    }], function () { return [{ type: i1.MapState }, { type: i2.ToolState }, { type: i3.ImportExportState }]; }, { toggleLegendOnVisibilityChange: [{
+            type: Input
+        }], expandLegendOfVisibleLayers: [{
+            type: Input
+        }], updateLegendOnResolutionChange: [{
+            type: Input
+        }], ogcButton: [{
+            type: Input
+        }], timeButton: [{
+            type: Input
+        }], layerListControls: [{
+            type: Input
+        }], queryBadge: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map-tool.component.js","sourceRoot":"","sources":["../../../../../../packages/integration/src/lib/map/map-tool/map-tool.component.ts","../../../../../../packages/integration/src/lib/map/map-tool/map-tool.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ChangeDetectionStrategy, Input } from '@angular/core';\r\n\r\nimport { ToolComponent } from '@igo2/common';\r\nimport {\r\n  LayerListControlsEnum,\r\n  LayerListControlsOptions,\r\n  IgoMap,\r\n  ExportOptions,\r\n  Layer\r\n} from '@igo2/geo';\r\nimport { MapState } from './../map.state';\r\nimport {\r\n  ImportExportMode,\r\n  ImportExportState\r\n} from '../../import-export/import-export.state';\r\nimport { ToolState } from '../../tool/tool.state';\r\n\r\n/**\r\n * Tool to browse a map's layers or to choose a different map\r\n */\r\n@ToolComponent({\r\n  name: 'map',\r\n  title: 'igo.integration.tools.map',\r\n  icon: 'map'\r\n})\r\n@Component({\r\n  selector: 'igo-map-tool',\r\n  templateUrl: './map-tool.component.html',\r\n  styleUrls: ['./map-tool.component.scss'],\r\n  changeDetection: ChangeDetectionStrategy.OnPush\r\n})\r\nexport class MapToolComponent {\r\n  @Input() toggleLegendOnVisibilityChange: boolean = false;\r\n\r\n  @Input() expandLegendOfVisibleLayers: boolean = false;\r\n\r\n  @Input() updateLegendOnResolutionChange: boolean = false;\r\n\r\n  @Input() ogcButton: boolean = true;\r\n\r\n  @Input() timeButton: boolean = true;\r\n\r\n  @Input() layerListControls: LayerListControlsOptions = {};\r\n\r\n  @Input() queryBadge: boolean = false;\r\n\r\n  get map(): IgoMap {\r\n    return this.mapState.map;\r\n  }\r\n\r\n  get excludeBaseLayers(): boolean {\r\n    return this.layerListControls.excludeBaseLayers || false;\r\n  }\r\n\r\n  get layerFilterAndSortOptions(): any {\r\n    const filterSortOptions = Object.assign(\r\n      {\r\n        showToolbar: LayerListControlsEnum.default\r\n      },\r\n      this.layerListControls\r\n    );\r\n\r\n    switch (this.layerListControls.showToolbar) {\r\n      case LayerListControlsEnum.always:\r\n        filterSortOptions.showToolbar = LayerListControlsEnum.always;\r\n        break;\r\n      case LayerListControlsEnum.never:\r\n        filterSortOptions.showToolbar = LayerListControlsEnum.never;\r\n        break;\r\n      default:\r\n        break;\r\n    }\r\n    return filterSortOptions;\r\n  }\r\n\r\n  constructor(\r\n    private mapState: MapState,\r\n    private toolState: ToolState,\r\n    private importExportState: ImportExportState\r\n  ) {}\r\n\r\n  activateExport(layer: Layer) {\r\n    let id = layer.id;\r\n    if (layer.options.workspace?.workspaceId) {\r\n      id =\r\n        layer.options.workspace.workspaceId !== layer.id\r\n          ? layer.options.workspace.workspaceId\r\n          : layer.id;\r\n    }\r\n    this.importExportState.setsExportOptions({ layers: [id] } as ExportOptions);\r\n    this.importExportState.setMode(ImportExportMode.export);\r\n    this.toolState.toolbox.activateTool('importExport');\r\n  }\r\n}\r\n","<mat-tab-group>\r\n  <mat-tab [label]=\"'igo.integration.tools.map' | translate\">\r\n    <igo-layer-list\r\n      [map]=\"map\"\r\n      igoLayerListBinding\r\n      [excludeBaseLayers]=\"excludeBaseLayers\"\r\n      [layerFilterAndSortOptions]=\"layerFilterAndSortOptions\"\r\n      [expandLegendOfVisibleLayers]=\"expandLegendOfVisibleLayers\"\r\n      [toggleLegendOnVisibilityChange]=\"toggleLegendOnVisibilityChange\"\r\n      [updateLegendOnResolutionChange]=\"updateLegendOnResolutionChange\"\r\n      [floatLabel]=\"false\"\r\n      [queryBadge]=\"queryBadge\"\r\n    >\r\n      <ng-template #igoLayerItemToolbar let-layer=\"layer\">\r\n        <!-- <igo-download-button [layer]=\"layer\"></igo-download-button> -->\r\n        <igo-workspace-button [layer]=\"layer\"></igo-workspace-button>\r\n        <igo-export-button\r\n          [layer]=\"layer\"\r\n          (click)=\"activateExport(layer)\"\r\n        ></igo-export-button>\r\n        <igo-ogc-filter-button\r\n          [header]=\"ogcButton\"\r\n          [layer]=\"layer\"\r\n        ></igo-ogc-filter-button>\r\n        <igo-time-filter-button\r\n          [header]=\"timeButton\"\r\n          [layer]=\"layer\"\r\n        ></igo-time-filter-button>\r\n        <igo-track-feature-button\r\n          [trackFeature]=\"true\"\r\n          [layer]=\"layer\"\r\n        ></igo-track-feature-button>\r\n        <igo-metadata-button [layer]=\"layer\"></igo-metadata-button>\r\n      </ng-template>\r\n    </igo-layer-list>\r\n  </mat-tab>\r\n\r\n  <mat-tab [label]=\"'igo.integration.tools.contexts' | translate\">\r\n    <igo-context-list igoContextListBinding></igo-context-list>\r\n  </mat-tab>\r\n</mat-tab-group>\r\n"]}

package/{esm2020 → esm2022}/lib/map/map-tools/index.mjs

@@ -1,2 +1,2 @@
-export * from './map-tools.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9pbnRlZ3JhdGlvbi9zcmMvbGliL21hcC9tYXAtdG9vbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbWFwLXRvb2xzLmNvbXBvbmVudCc7XHJcbiJdfQ==
+export * from './map-tools.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9pbnRlZ3JhdGlvbi9zcmMvbGliL21hcC9tYXAtdG9vbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbWFwLXRvb2xzLmNvbXBvbmVudCc7XG4iXX0=