@igo2/integration 18.0.1-next.1 → 18.0.1

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

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

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

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

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

@@ -0,0 +1,152 @@
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input } from '@angular/core';
+import { MatTabsModule } from '@angular/material/tabs';
+import { ToolComponent } from '@igo2/common/tool';
+import { ContextListBindingDirective, ContextListComponent } from '@igo2/context';
+import { ConfigService } from '@igo2/core/config';
+import { IgoLanguageModule } from '@igo2/core/language';
+import { Media, MediaService } from '@igo2/core/media';
+import { ExportButtonComponent, LayerListControlsEnum, LayerViewerComponent, MetadataButtonComponent, OgcFilterButtonComponent, TimeFilterButtonComponent, TrackFeatureButtonComponent } from '@igo2/geo';
+import { ImportExportMode, ImportExportState } from '../../import-export/import-export.state';
+import { ToolState } from '../../tool/tool.state';
+import { WorkspaceButtonComponent } from '../../workspace/workspace-button/workspace-button.component';
+import { MapState } from './../map.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 "@igo2/core/config";
+import * as i5 from "@igo2/core/media";
+import * as i6 from "@angular/material/tabs";
+import * as i7 from "@ngx-translate/core";
+/**
+ * Tool to browse a map's layers or to choose a different map
+ */
+let MapToolComponent = class MapToolComponent {
+    mapState;
+    toolState;
+    importExportState;
+    configService;
+    mediaService;
+    cdr;
+    isDesktop;
+    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;
+    }
+    _layerViewerOptions;
+    get layerViewerOptions() {
+        return {
+            filterAndSortOptions: this.layerFilterAndSortOptions,
+            legend: {
+                showForVisibleLayers: this.expandLegendOfVisibleLayers,
+                showOnVisibilityChange: this.toggleLegendOnVisibilityChange,
+                updateOnResolutionChange: this.updateLegendOnResolutionChange
+            },
+            queryBadge: this.queryBadge,
+            ...this._layerViewerOptions
+        };
+    }
+    constructor(mapState, toolState, importExportState, configService, mediaService, cdr) {
+        this.mapState = mapState;
+        this.toolState = toolState;
+        this.importExportState = importExportState;
+        this.configService = configService;
+        this.mediaService = mediaService;
+        this.cdr = cdr;
+        this._layerViewerOptions = this.configService.getConfig('layer');
+    }
+    ngOnInit() {
+        this.handleMedia();
+    }
+    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');
+    }
+    handleMedia() {
+        this.mediaService.media$.subscribe((result) => {
+            this.isDesktop = result === Media.Desktop;
+            this.cdr.detectChanges();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MapToolComponent, deps: [{ token: i1.MapState }, { token: i2.ToolState }, { token: i3.ImportExportState }, { token: i4.ConfigService }, { token: i5.MediaService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: MapToolComponent, isStandalone: true, selector: "igo-map-tool", inputs: { toggleLegendOnVisibilityChange: "toggleLegendOnVisibilityChange", expandLegendOfVisibleLayers: "expandLegendOfVisibleLayers", updateLegendOnResolutionChange: "updateLegendOnResolutionChange", ogcButton: "ogcButton", timeButton: "timeButton", layerListControls: "layerListControls", queryBadge: "queryBadge" }, ngImport: i0, template: "<mat-tab-group>\n  <mat-tab [label]=\"'igo.integration.tools.map' | translate\">\n    <igo-layer-viewer\n      [map]=\"map\"\n      [options]=\"layerViewerOptions\"\n      [excludeBaseLayers]=\"excludeBaseLayers\"\n      [isDesktop]=\"isDesktop\"\n    >\n      <ng-template #customBottomActions let-layer=\"layer\">\n        <igo-workspace-button [layer]=\"layer\"></igo-workspace-button>\n        <igo-export-button\n          [layer]=\"layer\"\n          (click)=\"activateExport(layer)\"\n        ></igo-export-button>\n        <igo-ogc-filter-button\n          [header]=\"ogcButton\"\n          [layer]=\"layer\"\n        ></igo-ogc-filter-button>\n        <igo-time-filter-button\n          [header]=\"timeButton\"\n          [layer]=\"layer\"\n        ></igo-time-filter-button>\n        <igo-track-feature-button\n          [trackFeature]=\"true\"\n          [layer]=\"layer\"\n        ></igo-track-feature-button>\n        <igo-metadata-button [layer]=\"layer\"></igo-metadata-button>\n      </ng-template>\n    </igo-layer-viewer>\n  </mat-tab>\n\n  <mat-tab [label]=\"'igo.integration.tools.contexts' | translate\">\n    <igo-context-list igoContextListBinding></igo-context-list>\n  </mat-tab>\n</mat-tab-group>\n", styles: [":host ::ng-deep .mat-mdc-tab-body-content{overflow:hidden}\n"], dependencies: [{ kind: "ngmodule", type: MatTabsModule }, { kind: "component", type: i6.MatTab, selector: "mat-tab", inputs: ["disabled", "label", "aria-label", "aria-labelledby", "labelClass", "bodyClass"], exportAs: ["matTab"] }, { kind: "component", type: i6.MatTabGroup, selector: "mat-tab-group", inputs: ["color", "fitInkBarToContent", "mat-stretch-tabs", "dynamicHeight", "selectedIndex", "headerPosition", "animationDuration", "contentTabIndex", "disablePagination", "disableRipple", "preserveContent", "backgroundColor", "aria-label", "aria-labelledby"], outputs: ["selectedIndexChange", "focusChange", "animationDone", "selectedTabChange"], exportAs: ["matTabGroup"] }, { kind: "component", type: WorkspaceButtonComponent, selector: "igo-workspace-button", inputs: ["layer", "color"] }, { kind: "component", type: ExportButtonComponent, selector: "igo-export-button", inputs: ["layer", "color"] }, { kind: "component", type: OgcFilterButtonComponent, selector: "igo-ogc-filter-button", inputs: ["layer", "map", "color", "header"] }, { kind: "component", type: TimeFilterButtonComponent, selector: "igo-time-filter-button", inputs: ["layer", "map", "color", "header"] }, { kind: "component", type: TrackFeatureButtonComponent, selector: "igo-track-feature-button", inputs: ["layer", "trackFeature"] }, { kind: "component", type: MetadataButtonComponent, selector: "igo-metadata-button", inputs: ["layer", "color"] }, { kind: "component", type: LayerViewerComponent, selector: "igo-layer-viewer", inputs: ["map", "options", "isDesktop", "excludeBaseLayers"], outputs: ["appliedFilterAndSort"] }, { kind: "component", type: ContextListComponent, selector: "igo-context-list", inputs: ["contexts", "selectedContext", "map", "defaultContextId", "term"], outputs: ["select", "unselect", "edit", "delete", "save", "clone", "create", "hide", "show", "showHiddenContexts", "favorite", "managePermissions", "manageTools", "filterPermissionsChanged"] }, { kind: "directive", type: ContextListBindingDirective, selector: "[igoContextListBinding]" }, { kind: "ngmodule", type: IgoLanguageModule }, { kind: "pipe", type: i7.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+MapToolComponent = __decorate([
+    ToolComponent({
+        name: 'map',
+        title: 'igo.integration.tools.map',
+        icon: 'map'
+    }),
+    __metadata("design:paramtypes", [MapState,
+        ToolState,
+        ImportExportState,
+        ConfigService,
+        MediaService,
+        ChangeDetectorRef])
+], MapToolComponent);
+export { MapToolComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MapToolComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'igo-map-tool', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                        MatTabsModule,
+                        WorkspaceButtonComponent,
+                        ExportButtonComponent,
+                        OgcFilterButtonComponent,
+                        TimeFilterButtonComponent,
+                        TrackFeatureButtonComponent,
+                        MetadataButtonComponent,
+                        LayerViewerComponent,
+                        ContextListComponent,
+                        ContextListBindingDirective,
+                        IgoLanguageModule
+                    ], template: "<mat-tab-group>\n  <mat-tab [label]=\"'igo.integration.tools.map' | translate\">\n    <igo-layer-viewer\n      [map]=\"map\"\n      [options]=\"layerViewerOptions\"\n      [excludeBaseLayers]=\"excludeBaseLayers\"\n      [isDesktop]=\"isDesktop\"\n    >\n      <ng-template #customBottomActions let-layer=\"layer\">\n        <igo-workspace-button [layer]=\"layer\"></igo-workspace-button>\n        <igo-export-button\n          [layer]=\"layer\"\n          (click)=\"activateExport(layer)\"\n        ></igo-export-button>\n        <igo-ogc-filter-button\n          [header]=\"ogcButton\"\n          [layer]=\"layer\"\n        ></igo-ogc-filter-button>\n        <igo-time-filter-button\n          [header]=\"timeButton\"\n          [layer]=\"layer\"\n        ></igo-time-filter-button>\n        <igo-track-feature-button\n          [trackFeature]=\"true\"\n          [layer]=\"layer\"\n        ></igo-track-feature-button>\n        <igo-metadata-button [layer]=\"layer\"></igo-metadata-button>\n      </ng-template>\n    </igo-layer-viewer>\n  </mat-tab>\n\n  <mat-tab [label]=\"'igo.integration.tools.contexts' | translate\">\n    <igo-context-list igoContextListBinding></igo-context-list>\n  </mat-tab>\n</mat-tab-group>\n", styles: [":host ::ng-deep .mat-mdc-tab-body-content{overflow:hidden}\n"] }]
+        }], ctorParameters: () => [{ type: i1.MapState }, { type: i2.ToolState }, { type: i3.ImportExportState }, { type: i4.ConfigService }, { type: i5.MediaService }, { type: i0.ChangeDetectorRef }], propDecorators: { 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":";AAAA,OAAO,EACL,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EACT,KAAK,EAEN,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAEvD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EACL,2BAA2B,EAC3B,oBAAoB,EACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EACL,qBAAqB,EAIrB,qBAAqB,EAErB,oBAAoB,EAEpB,uBAAuB,EACvB,wBAAwB,EACxB,yBAAyB,EACzB,2BAA2B,EAC5B,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,wBAAwB,EAAE,MAAM,6DAA6D,CAAC;AACvG,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;;;;;;;;;AAE1C;;GAEG;AA0BI,IAAM,gBAAgB,GAAtB,MAAM,gBAAgB;IA6DjB;IACA;IACA;IACA;IACD;IACC;IAjEV,SAAS,CAAU;IAEV,8BAA8B,GAAG,KAAK,CAAC;IAEvC,2BAA2B,GAAG,KAAK,CAAC;IAEpC,8BAA8B,GAAG,KAAK,CAAC;IAEvC,SAAS,GAAG,IAAI,CAAC;IAEjB,UAAU,GAAG,IAAI,CAAC;IAElB,iBAAiB,GAA6B,EAAE,CAAC;IAEjD,UAAU,GAAG,KAAK,CAAC;IAE5B,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;IAC3B,CAAC;IAED,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,IAAI,KAAK,CAAC;IAC3D,CAAC;IAED,IAAI,yBAAyB;QAC3B,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,CACrC;YACE,WAAW,EAAE,qBAAqB,CAAC,OAAO;SAC3C,EACD,IAAI,CAAC,iBAAiB,CACvB,CAAC;QAEF,QAAQ,IAAI,CAAC,iBAAiB,CAAC,WAAW,EAAE,CAAC;YAC3C,KAAK,qBAAqB,CAAC,MAAM;gBAC/B,iBAAiB,CAAC,WAAW,GAAG,qBAAqB,CAAC,MAAM,CAAC;gBAC7D,MAAM;YACR,KAAK,qBAAqB,CAAC,KAAK;gBAC9B,iBAAiB,CAAC,WAAW,GAAG,qBAAqB,CAAC,KAAK,CAAC;gBAC5D,MAAM;YACR;gBACE,MAAM;QACV,CAAC;QACD,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAEO,mBAAmB,CAA8B;IACzD,IAAI,kBAAkB;QACpB,OAAO;YACL,oBAAoB,EAAE,IAAI,CAAC,yBAAyB;YACpD,MAAM,EAAE;gBACN,oBAAoB,EAAE,IAAI,CAAC,2BAA2B;gBACtD,sBAAsB,EAAE,IAAI,CAAC,8BAA8B;gBAC3D,wBAAwB,EAAE,IAAI,CAAC,8BAA8B;aAC9D;YACD,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,GAAG,IAAI,CAAC,mBAAmB;SAC5B,CAAC;IACJ,CAAC;IAED,YACU,QAAkB,EAClB,SAAoB,EACpB,iBAAoC,EACpC,aAA4B,EAC7B,YAA0B,EACzB,GAAsB;QALtB,aAAQ,GAAR,QAAQ,CAAU;QAClB,cAAS,GAAT,SAAS,CAAW;QACpB,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,kBAAa,GAAb,aAAa,CAAe;QAC7B,iBAAY,GAAZ,YAAY,CAAc;QACzB,QAAG,GAAH,GAAG,CAAmB;QAE9B,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IACnE,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,WAAW,EAAE,CAAC;IACrB,CAAC;IAED,cAAc,CAAC,KAAY;QACzB,IAAI,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC;QAClB,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,EAAE,WAAW,EAAE,CAAC;YACzC,EAAE;gBACA,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,WAAW,KAAK,KAAK,CAAC,EAAE;oBAC9C,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,WAAW;oBACrC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;QACjB,CAAC;QACD,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,EAAmB,CAAC,CAAC;QAC5E,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QACxD,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;IACtD,CAAC;IAEO,WAAW;QACjB,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;YAC5C,IAAI,CAAC,SAAS,GAAG,MAAM,KAAK,KAAK,CAAC,OAAO,CAAC;YAC1C,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC;QAC3B,CAAC,CAAC,CAAC;IACL,CAAC;wGA7FU,gBAAgB;4FAAhB,gBAAgB,wYCpE7B,0sCAmCA,qHDoBI,aAAa,6oBACb,wBAAwB,6FACxB,qBAAqB,0FACrB,wBAAwB,+GACxB,yBAAyB,gHACzB,2BAA2B,wGAC3B,uBAAuB,4FACvB,oBAAoB,8JACpB,oBAAoB,yUACpB,2BAA2B,mEAC3B,iBAAiB;;AAGR,gBAAgB;IAzB5B,aAAa,CAAC;QACb,IAAI,EAAE,KAAK;QACX,KAAK,EAAE,2BAA2B;QAClC,IAAI,EAAE,KAAK;KACZ,CAAC;qCAkFoB,QAAQ;QACP,SAAS;QACD,iBAAiB;QACrB,aAAa;QACf,YAAY;QACpB,iBAAiB;GAlErB,gBAAgB,CA8F5B;;4FA9FY,gBAAgB;kBApB5B,SAAS;+BACE,cAAc,mBAGP,uBAAuB,CAAC,MAAM,cACnC,IAAI,WACP;wBACP,aAAa;wBACb,wBAAwB;wBACxB,qBAAqB;wBACrB,wBAAwB;wBACxB,yBAAyB;wBACzB,2BAA2B;wBAC3B,uBAAuB;wBACvB,oBAAoB;wBACpB,oBAAoB;wBACpB,2BAA2B;wBAC3B,iBAAiB;qBAClB;4NAKQ,8BAA8B;sBAAtC,KAAK;gBAEG,2BAA2B;sBAAnC,KAAK;gBAEG,8BAA8B;sBAAtC,KAAK;gBAEG,SAAS;sBAAjB,KAAK;gBAEG,UAAU;sBAAlB,KAAK;gBAEG,iBAAiB;sBAAzB,KAAK;gBAEG,UAAU;sBAAlB,KAAK","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  Input,\n  OnInit\n} from '@angular/core';\nimport { MatTabsModule } from '@angular/material/tabs';\n\nimport { ToolComponent } from '@igo2/common/tool';\nimport {\n  ContextListBindingDirective,\n  ContextListComponent\n} from '@igo2/context';\nimport { ConfigService } from '@igo2/core/config';\nimport { IgoLanguageModule } from '@igo2/core/language';\nimport { Media, MediaService } from '@igo2/core/media';\nimport {\n  ExportButtonComponent,\n  ExportOptions,\n  IgoMap,\n  Layer,\n  LayerListControlsEnum,\n  LayerListControlsOptions,\n  LayerViewerComponent,\n  LayerViewerOptions,\n  MetadataButtonComponent,\n  OgcFilterButtonComponent,\n  TimeFilterButtonComponent,\n  TrackFeatureButtonComponent\n} from '@igo2/geo';\n\nimport {\n  ImportExportMode,\n  ImportExportState\n} from '../../import-export/import-export.state';\nimport { ToolState } from '../../tool/tool.state';\nimport { WorkspaceButtonComponent } from '../../workspace/workspace-button/workspace-button.component';\nimport { MapState } from './../map.state';\n\n/**\n * Tool to browse a map's layers or to choose a different map\n */\n@ToolComponent({\n  name: 'map',\n  title: 'igo.integration.tools.map',\n  icon: 'map'\n})\n@Component({\n  selector: 'igo-map-tool',\n  templateUrl: './map-tool.component.html',\n  styleUrls: ['./map-tool.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    MatTabsModule,\n    WorkspaceButtonComponent,\n    ExportButtonComponent,\n    OgcFilterButtonComponent,\n    TimeFilterButtonComponent,\n    TrackFeatureButtonComponent,\n    MetadataButtonComponent,\n    LayerViewerComponent,\n    ContextListComponent,\n    ContextListBindingDirective,\n    IgoLanguageModule\n  ]\n})\nexport class MapToolComponent implements OnInit {\n  isDesktop: boolean;\n\n  @Input() toggleLegendOnVisibilityChange = false;\n\n  @Input() expandLegendOfVisibleLayers = false;\n\n  @Input() updateLegendOnResolutionChange = false;\n\n  @Input() ogcButton = true;\n\n  @Input() timeButton = true;\n\n  @Input() layerListControls: LayerListControlsOptions = {};\n\n  @Input() queryBadge = false;\n\n  get map(): IgoMap {\n    return this.mapState.map;\n  }\n\n  get excludeBaseLayers(): boolean {\n    return this.layerListControls.excludeBaseLayers || false;\n  }\n\n  get layerFilterAndSortOptions(): any {\n    const filterSortOptions = Object.assign(\n      {\n        showToolbar: LayerListControlsEnum.default\n      },\n      this.layerListControls\n    );\n\n    switch (this.layerListControls.showToolbar) {\n      case LayerListControlsEnum.always:\n        filterSortOptions.showToolbar = LayerListControlsEnum.always;\n        break;\n      case LayerListControlsEnum.never:\n        filterSortOptions.showToolbar = LayerListControlsEnum.never;\n        break;\n      default:\n        break;\n    }\n    return filterSortOptions;\n  }\n\n  private _layerViewerOptions: Partial<LayerViewerOptions>;\n  get layerViewerOptions(): LayerViewerOptions {\n    return {\n      filterAndSortOptions: this.layerFilterAndSortOptions,\n      legend: {\n        showForVisibleLayers: this.expandLegendOfVisibleLayers,\n        showOnVisibilityChange: this.toggleLegendOnVisibilityChange,\n        updateOnResolutionChange: this.updateLegendOnResolutionChange\n      },\n      queryBadge: this.queryBadge,\n      ...this._layerViewerOptions\n    };\n  }\n\n  constructor(\n    private mapState: MapState,\n    private toolState: ToolState,\n    private importExportState: ImportExportState,\n    private configService: ConfigService,\n    public mediaService: MediaService,\n    private cdr: ChangeDetectorRef\n  ) {\n    this._layerViewerOptions = this.configService.getConfig('layer');\n  }\n\n  ngOnInit(): void {\n    this.handleMedia();\n  }\n\n  activateExport(layer: Layer) {\n    let id = layer.id;\n    if (layer.options.workspace?.workspaceId) {\n      id =\n        layer.options.workspace.workspaceId !== layer.id\n          ? layer.options.workspace.workspaceId\n          : layer.id;\n    }\n    this.importExportState.setsExportOptions({ layers: [id] } as ExportOptions);\n    this.importExportState.setMode(ImportExportMode.export);\n    this.toolState.toolbox.activateTool('importExport');\n  }\n\n  private handleMedia(): void {\n    this.mediaService.media$.subscribe((result) => {\n      this.isDesktop = result === Media.Desktop;\n      this.cdr.detectChanges();\n    });\n  }\n}\n","<mat-tab-group>\n  <mat-tab [label]=\"'igo.integration.tools.map' | translate\">\n    <igo-layer-viewer\n      [map]=\"map\"\n      [options]=\"layerViewerOptions\"\n      [excludeBaseLayers]=\"excludeBaseLayers\"\n      [isDesktop]=\"isDesktop\"\n    >\n      <ng-template #customBottomActions let-layer=\"layer\">\n        <igo-workspace-button [layer]=\"layer\"></igo-workspace-button>\n        <igo-export-button\n          [layer]=\"layer\"\n          (click)=\"activateExport(layer)\"\n        ></igo-export-button>\n        <igo-ogc-filter-button\n          [header]=\"ogcButton\"\n          [layer]=\"layer\"\n        ></igo-ogc-filter-button>\n        <igo-time-filter-button\n          [header]=\"timeButton\"\n          [layer]=\"layer\"\n        ></igo-time-filter-button>\n        <igo-track-feature-button\n          [trackFeature]=\"true\"\n          [layer]=\"layer\"\n        ></igo-track-feature-button>\n        <igo-metadata-button [layer]=\"layer\"></igo-metadata-button>\n      </ng-template>\n    </igo-layer-viewer>\n  </mat-tab>\n\n  <mat-tab [label]=\"'igo.integration.tools.contexts' | translate\">\n    <igo-context-list igoContextListBinding></igo-context-list>\n  </mat-tab>\n</mat-tab-group>\n"]}

package/esm2022/lib/map/map-tools/index.mjs

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