@igo2/context 1.15.4 → 1.15.5

package/esm2020/lib/context-manager/shared/index.mjs

@@ -1,6 +1,6 @@
-export * from './context.service';
-export * from './context.enum';
-export * from './context.interface';
-export * from './layer-context.directive';
-export * from './map-context.directive';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb250ZXh0L3NyYy9saWIvY29udGV4dC1tYW5hZ2VyL3NoYXJlZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMseUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbnRleHQuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vY29udGV4dC5lbnVtJztcclxuZXhwb3J0ICogZnJvbSAnLi9jb250ZXh0LmludGVyZmFjZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGF5ZXItY29udGV4dC5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL21hcC1jb250ZXh0LmRpcmVjdGl2ZSc7XHJcbiJdfQ==
+export * from './context.service';
+export * from './context.enum';
+export * from './context.interface';
+export * from './layer-context.directive';
+export * from './map-context.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb250ZXh0L3NyYy9saWIvY29udGV4dC1tYW5hZ2VyL3NoYXJlZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMseUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbnRleHQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRleHQuZW51bSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRleHQuaW50ZXJmYWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGF5ZXItY29udGV4dC5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9tYXAtY29udGV4dC5kaXJlY3RpdmUnO1xuIl19

package/esm2020/lib/context-manager/shared/layer-context.directive.mjs

@@ -1,162 +1,162 @@
-import { Directive, Optional, Input } from '@angular/core';
-import { merge } from 'rxjs';
-import { buffer, debounceTime, filter } from 'rxjs/operators';
-import { addImportedFeaturesToMap, addImportedFeaturesStyledToMap } from '../../context-import-export/shared/context-import.utils';
-import GeoJSON from 'ol/format/GeoJSON';
-import * as i0 from "@angular/core";
-import * as i1 from "@igo2/geo";
-import * as i2 from "./context.service";
-import * as i3 from "@igo2/core";
-export class LayerContextDirective {
-    constructor(component, contextService, layerService, configService, styleListService, styleService, route) {
-        this.component = component;
-        this.contextService = contextService;
-        this.layerService = layerService;
-        this.configService = configService;
-        this.styleListService = styleListService;
-        this.styleService = styleService;
-        this.route = route;
-        this.contextLayers = [];
-        this.removeLayersOnContextChange = true;
-    }
-    get map() {
-        return this.component.map;
-    }
-    ngOnInit() {
-        this.context$$ = this.contextService.context$
-            .pipe(filter((context) => context !== undefined))
-            .subscribe((context) => this.handleContextChange(context));
-        if (this.route &&
-            this.route.options.visibleOnLayersKey &&
-            this.route.options.visibleOffLayersKey &&
-            this.route.options.contextKey) {
-            const queryParams$$ = this.route.queryParams.subscribe((params) => {
-                if (Object.keys(params).length > 0) {
-                    this.queryParams = params;
-                    queryParams$$.unsubscribe();
-                }
-            });
-        }
-    }
-    ngOnDestroy() {
-        this.context$$.unsubscribe();
-    }
-    handleContextChange(context) {
-        if (context.layers === undefined) {
-            return;
-        }
-        if (this.removeLayersOnContextChange === true) {
-            this.map.removeAllLayers();
-        }
-        else {
-            this.map.removeLayers(this.contextLayers);
-        }
-        this.contextLayers = [];
-        const layersAndIndex$ = merge(...context.layers.map((layerOptions, index) => {
-            return this.layerService.createAsyncLayer(layerOptions, context.uri);
-        }));
-        layersAndIndex$
-            .pipe(buffer(layersAndIndex$.pipe(debounceTime(500))))
-            .subscribe((layers) => {
-            this.handleAddLayers(layers);
-            if (context.extraFeatures) {
-                context.extraFeatures.forEach((featureCollection) => {
-                    const format = new GeoJSON();
-                    const title = featureCollection.name;
-                    featureCollection = JSON.stringify(featureCollection);
-                    featureCollection = format.readFeatures(featureCollection, {
-                        dataProjection: 'EPSG:4326',
-                        featureProjection: 'EPSG:3857'
-                    });
-                    const importExportOptions = this.configService.getConfig('importExport');
-                    const importWithStyle = importExportOptions?.importWithStyle || this.configService.getConfig('importWithStyle');
-                    if (this.configService.getConfig('importWithStyle')) {
-                        console.warn(`
-              The location of this config importWithStyle is deprecated.
-              Please move this property within importExport configuration.
-              Ex: importWithStyle: true/false must be transfered to importExport: { importWithStyle: true/false }
-              Refer to environnement.ts OR config/config.json
-              This legacy conversion will be deleted in 2024.
-              `);
-                    }
-                    if (!importWithStyle) {
-                        addImportedFeaturesToMap(featureCollection, this.map, title);
-                    }
-                    else {
-                        addImportedFeaturesStyledToMap(featureCollection, this.map, title, this.styleListService, this.styleService);
-                    }
-                });
-            }
-        });
-        this.layerService.createAsyncIdbLayers(context.uri).pipe(debounceTime(500))
-            .subscribe((layers) => this.handleAddLayers(layers));
-    }
-    handleAddLayers(layers) {
-        layers = layers
-            .filter((layer) => layer !== undefined)
-            .map((layer) => {
-            layer.visible = this.computeLayerVisibilityFromUrl(layer);
-            layer.zIndex = layer.zIndex;
-            return layer;
-        });
-        this.contextLayers.concat(layers);
-        this.map.addLayers(layers);
-    }
-    computeLayerVisibilityFromUrl(layer) {
-        const params = this.queryParams;
-        const currentContext = this.contextService.context$.value.uri;
-        const currentLayerid = layer.id;
-        let visible = layer.visible;
-        if (!params || !currentLayerid) {
-            return visible;
-        }
-        const contextParams = params[this.route.options.contextKey];
-        if (contextParams === currentContext || !contextParams) {
-            let visibleOnLayersParams = '';
-            let visibleOffLayersParams = '';
-            let visiblelayers = [];
-            let invisiblelayers = [];
-            if (this.route.options.visibleOnLayersKey &&
-                params[this.route.options.visibleOnLayersKey]) {
-                visibleOnLayersParams =
-                    params[this.route.options.visibleOnLayersKey];
-            }
-            if (this.route.options.visibleOffLayersKey &&
-                params[this.route.options.visibleOffLayersKey]) {
-                visibleOffLayersParams =
-                    params[this.route.options.visibleOffLayersKey];
-            }
-            /* This order is important because to control whichever
-             the order of * param. First whe open and close everything.*/
-            if (visibleOnLayersParams === '*') {
-                visible = true;
-            }
-            if (visibleOffLayersParams === '*') {
-                visible = false;
-            }
-            // After, managing named layer by id (context.json OR id from datasource)
-            visiblelayers = visibleOnLayersParams.split(',');
-            invisiblelayers = visibleOffLayersParams.split(',');
-            if (visiblelayers.indexOf(currentLayerid) > -1 || visiblelayers.indexOf(currentLayerid.toString()) > -1) {
-                visible = true;
-            }
-            if (invisiblelayers.indexOf(currentLayerid) > -1 || invisiblelayers.indexOf(currentLayerid.toString()) > -1) {
-                visible = false;
-            }
-        }
-        return visible;
-    }
-}
-LayerContextDirective.ɵfac = function LayerContextDirective_Factory(t) { return new (t || LayerContextDirective)(i0.ɵɵdirectiveInject(i1.MapBrowserComponent), i0.ɵɵdirectiveInject(i2.ContextService), i0.ɵɵdirectiveInject(i1.LayerService), i0.ɵɵdirectiveInject(i3.ConfigService), i0.ɵɵdirectiveInject(i1.StyleListService), i0.ɵɵdirectiveInject(i1.StyleService), i0.ɵɵdirectiveInject(i3.RouteService, 8)); };
-LayerContextDirective.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: LayerContextDirective, selectors: [["", "igoLayerContext", ""]], inputs: { removeLayersOnContextChange: "removeLayersOnContextChange" } });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LayerContextDirective, [{
-        type: Directive,
-        args: [{
-                selector: '[igoLayerContext]'
-            }]
-    }], function () { return [{ type: i1.MapBrowserComponent }, { type: i2.ContextService }, { type: i1.LayerService }, { type: i3.ConfigService }, { type: i1.StyleListService }, { type: i1.StyleService }, { type: i3.RouteService, decorators: [{
-                type: Optional
-            }] }]; }, { removeLayersOnContextChange: [{
-            type: Input
-        }] }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"layer-context.directive.js","sourceRoot":"","sources":["../../../../../../packages/context/src/lib/context-manager/shared/layer-context.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, OnInit, OnDestroy, Optional, Input } from '@angular/core';\r\n\r\nimport { Subscription, merge } from 'rxjs';\r\nimport { buffer, debounceTime, filter } from 'rxjs/operators';\r\n\r\nimport { RouteService, ConfigService } from '@igo2/core';\r\nimport {\r\n  MapBrowserComponent,\r\n  Layer,\r\n  LayerService,\r\n  LayerOptions,\r\n  StyleListService,\r\n  StyleService\r\n} from '@igo2/geo';\r\nimport type { IgoMap } from '@igo2/geo';\r\n\r\nimport { ContextService } from './context.service';\r\nimport { DetailedContext } from './context.interface';\r\nimport {\r\n  addImportedFeaturesToMap,\r\n  addImportedFeaturesStyledToMap\r\n} from '../../context-import-export/shared/context-import.utils';\r\nimport GeoJSON from 'ol/format/GeoJSON';\r\n\r\n@Directive({\r\n  selector: '[igoLayerContext]'\r\n})\r\nexport class LayerContextDirective implements OnInit, OnDestroy {\r\n  private context$$: Subscription;\r\n  private queryParams: any;\r\n\r\n  private contextLayers: Layer[] = [];\r\n\r\n  @Input() removeLayersOnContextChange: boolean = true;\r\n\r\n  get map(): IgoMap {\r\n    return this.component.map;\r\n  }\r\n\r\n  constructor(\r\n    private component: MapBrowserComponent,\r\n    private contextService: ContextService,\r\n    private layerService: LayerService,\r\n    private configService: ConfigService,\r\n    private styleListService: StyleListService,\r\n    private styleService: StyleService,\r\n    @Optional() private route: RouteService\r\n  ) {}\r\n\r\n  ngOnInit() {\r\n    this.context$$ = this.contextService.context$\r\n      .pipe(filter((context) => context !== undefined))\r\n      .subscribe((context) => this.handleContextChange(context));\r\n\r\n    if (\r\n      this.route &&\r\n      this.route.options.visibleOnLayersKey &&\r\n      this.route.options.visibleOffLayersKey &&\r\n      this.route.options.contextKey\r\n    ) {\r\n      const queryParams$$ = this.route.queryParams.subscribe((params) => {\r\n        if (Object.keys(params).length > 0) {\r\n          this.queryParams = params;\r\n          queryParams$$.unsubscribe();\r\n        }\r\n      });\r\n    }\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.context$$.unsubscribe();\r\n  }\r\n\r\n  private handleContextChange(context: DetailedContext) {\r\n    if (context.layers === undefined) {\r\n      return;\r\n    }\r\n    if (this.removeLayersOnContextChange === true) {\r\n      this.map.removeAllLayers();\r\n    } else {\r\n      this.map.removeLayers(this.contextLayers);\r\n    }\r\n    this.contextLayers = [];\r\n\r\n    const layersAndIndex$ = merge(\r\n      ...context.layers.map((layerOptions: LayerOptions, index: number) => {\r\n        return this.layerService.createAsyncLayer(layerOptions, context.uri);\r\n      })\r\n    );\r\n\r\n    layersAndIndex$\r\n      .pipe(buffer(layersAndIndex$.pipe(debounceTime(500))))\r\n      .subscribe((layers: Layer[]) => {\r\n        this.handleAddLayers(layers);\r\n\r\n        if (context.extraFeatures) {\r\n          context.extraFeatures.forEach((featureCollection) => {\r\n            const format = new GeoJSON();\r\n            const title = featureCollection.name;\r\n            featureCollection = JSON.stringify(featureCollection);\r\n            featureCollection = format.readFeatures(featureCollection, {\r\n              dataProjection: 'EPSG:4326',\r\n              featureProjection: 'EPSG:3857'\r\n            });\r\n            const importExportOptions = this.configService.getConfig('importExport');\r\n            const importWithStyle =importExportOptions?.importWithStyle || this.configService.getConfig('importWithStyle');\r\n            if (this.configService.getConfig('importWithStyle')) {\r\n              console.warn(`\r\n              The location of this config importWithStyle is deprecated.\r\n              Please move this property within importExport configuration.\r\n              Ex: importWithStyle: true/false must be transfered to importExport: { importWithStyle: true/false }\r\n              Refer to environnement.ts OR config/config.json\r\n              This legacy conversion will be deleted in 2024.\r\n              `);\r\n            }\r\n            if (!importWithStyle) {\r\n              addImportedFeaturesToMap(featureCollection, this.map, title);\r\n            } else {\r\n              addImportedFeaturesStyledToMap(\r\n                featureCollection,\r\n                this.map,\r\n                title,\r\n                this.styleListService,\r\n                this.styleService\r\n              );\r\n            }\r\n          });\r\n        }\r\n      });\r\n\r\n      this.layerService.createAsyncIdbLayers(context.uri).pipe(debounceTime(500))\r\n      .subscribe((layers: Layer[]) => this.handleAddLayers(layers));\r\n\r\n  }\r\n\r\n  private handleAddLayers(layers: Layer[]) {\r\n    layers = layers\r\n      .filter((layer: Layer) => layer !== undefined)\r\n      .map((layer) => {\r\n        layer.visible = this.computeLayerVisibilityFromUrl(layer);\r\n        layer.zIndex = layer.zIndex;\r\n\r\n        return layer;\r\n      });\r\n    this.contextLayers.concat(layers);\r\n    this.map.addLayers(layers);\r\n  }\r\n\r\n  private computeLayerVisibilityFromUrl(layer: Layer): boolean {\r\n    const params = this.queryParams;\r\n    const currentContext = this.contextService.context$.value.uri;\r\n    const currentLayerid: string = layer.id;\r\n\r\n    let visible = layer.visible;\r\n    if (!params || !currentLayerid) {\r\n      return visible;\r\n    }\r\n\r\n    const contextParams = params[this.route.options.contextKey as string];\r\n    if (contextParams === currentContext || !contextParams) {\r\n      let visibleOnLayersParams = '';\r\n      let visibleOffLayersParams = '';\r\n      let visiblelayers: string[] = [];\r\n      let invisiblelayers: string[] = [];\r\n\r\n      if (\r\n        this.route.options.visibleOnLayersKey &&\r\n        params[this.route.options.visibleOnLayersKey as string]\r\n      ) {\r\n        visibleOnLayersParams =\r\n          params[this.route.options.visibleOnLayersKey as string];\r\n      }\r\n      if (\r\n        this.route.options.visibleOffLayersKey &&\r\n        params[this.route.options.visibleOffLayersKey as string]\r\n      ) {\r\n        visibleOffLayersParams =\r\n          params[this.route.options.visibleOffLayersKey as string];\r\n      }\r\n\r\n      /* This order is important because to control whichever\r\n       the order of * param. First whe open and close everything.*/\r\n      if (visibleOnLayersParams === '*') {\r\n        visible = true;\r\n      }\r\n      if (visibleOffLayersParams === '*') {\r\n        visible = false;\r\n      }\r\n\r\n      // After, managing named layer by id (context.json OR id from datasource)\r\n      visiblelayers = visibleOnLayersParams.split(',');\r\n      invisiblelayers = visibleOffLayersParams.split(',');\r\n      if (visiblelayers.indexOf(currentLayerid) > -1 || visiblelayers.indexOf(currentLayerid.toString()) > -1) {\r\n        visible = true;\r\n      }\r\n      if (invisiblelayers.indexOf(currentLayerid) > -1 || invisiblelayers.indexOf(currentLayerid.toString()) > -1) {\r\n        visible = false;\r\n      }\r\n    }\r\n\r\n    return visible;\r\n  }\r\n}\r\n"]}
+import { Directive, Optional, Input } from '@angular/core';
+import { merge } from 'rxjs';
+import { buffer, debounceTime, filter } from 'rxjs/operators';
+import { addImportedFeaturesToMap, addImportedFeaturesStyledToMap } from '../../context-import-export/shared/context-import.utils';
+import GeoJSON from 'ol/format/GeoJSON';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/geo";
+import * as i2 from "./context.service";
+import * as i3 from "@igo2/core";
+export class LayerContextDirective {
+    constructor(component, contextService, layerService, configService, styleListService, styleService, route) {
+        this.component = component;
+        this.contextService = contextService;
+        this.layerService = layerService;
+        this.configService = configService;
+        this.styleListService = styleListService;
+        this.styleService = styleService;
+        this.route = route;
+        this.contextLayers = [];
+        this.removeLayersOnContextChange = true;
+    }
+    get map() {
+        return this.component.map;
+    }
+    ngOnInit() {
+        this.context$$ = this.contextService.context$
+            .pipe(filter((context) => context !== undefined))
+            .subscribe((context) => this.handleContextChange(context));
+        if (this.route &&
+            this.route.options.visibleOnLayersKey &&
+            this.route.options.visibleOffLayersKey &&
+            this.route.options.contextKey) {
+            const queryParams$$ = this.route.queryParams.subscribe((params) => {
+                if (Object.keys(params).length > 0) {
+                    this.queryParams = params;
+                    queryParams$$.unsubscribe();
+                }
+            });
+        }
+    }
+    ngOnDestroy() {
+        this.context$$.unsubscribe();
+    }
+    handleContextChange(context) {
+        if (context.layers === undefined) {
+            return;
+        }
+        if (this.removeLayersOnContextChange === true) {
+            this.map.removeAllLayers();
+        }
+        else {
+            this.map.removeLayers(this.contextLayers);
+        }
+        this.contextLayers = [];
+        const layersAndIndex$ = merge(...context.layers.map((layerOptions, index) => {
+            return this.layerService.createAsyncLayer(layerOptions, context.uri);
+        }));
+        layersAndIndex$
+            .pipe(buffer(layersAndIndex$.pipe(debounceTime(500))))
+            .subscribe((layers) => {
+            this.handleAddLayers(layers);
+            if (context.extraFeatures) {
+                context.extraFeatures.forEach((featureCollection) => {
+                    const format = new GeoJSON();
+                    const title = featureCollection.name;
+                    featureCollection = JSON.stringify(featureCollection);
+                    featureCollection = format.readFeatures(featureCollection, {
+                        dataProjection: 'EPSG:4326',
+                        featureProjection: 'EPSG:3857'
+                    });
+                    const importExportOptions = this.configService.getConfig('importExport');
+                    const importWithStyle = importExportOptions?.importWithStyle || this.configService.getConfig('importWithStyle');
+                    if (this.configService.getConfig('importWithStyle')) {
+                        console.warn(`
+              The location of this config importWithStyle is deprecated.
+              Please move this property within importExport configuration.
+              Ex: importWithStyle: true/false must be transfered to importExport: { importWithStyle: true/false }
+              Refer to environnement.ts OR config/config.json
+              This legacy conversion will be deleted in 2024.
+              `);
+                    }
+                    if (!importWithStyle) {
+                        addImportedFeaturesToMap(featureCollection, this.map, title);
+                    }
+                    else {
+                        addImportedFeaturesStyledToMap(featureCollection, this.map, title, this.styleListService, this.styleService);
+                    }
+                });
+            }
+        });
+        this.layerService.createAsyncIdbLayers(context.uri).pipe(debounceTime(500))
+            .subscribe((layers) => this.handleAddLayers(layers));
+    }
+    handleAddLayers(layers) {
+        layers = layers
+            .filter((layer) => layer !== undefined)
+            .map((layer) => {
+            layer.visible = this.computeLayerVisibilityFromUrl(layer);
+            layer.zIndex = layer.zIndex;
+            return layer;
+        });
+        this.contextLayers.concat(layers);
+        this.map.addLayers(layers);
+    }
+    computeLayerVisibilityFromUrl(layer) {
+        const params = this.queryParams;
+        const currentContext = this.contextService.context$.value.uri;
+        const currentLayerid = layer.id;
+        let visible = layer.visible;
+        if (!params || !currentLayerid) {
+            return visible;
+        }
+        const contextParams = params[this.route.options.contextKey];
+        if (contextParams === currentContext || !contextParams) {
+            let visibleOnLayersParams = '';
+            let visibleOffLayersParams = '';
+            let visiblelayers = [];
+            let invisiblelayers = [];
+            if (this.route.options.visibleOnLayersKey &&
+                params[this.route.options.visibleOnLayersKey]) {
+                visibleOnLayersParams =
+                    params[this.route.options.visibleOnLayersKey];
+            }
+            if (this.route.options.visibleOffLayersKey &&
+                params[this.route.options.visibleOffLayersKey]) {
+                visibleOffLayersParams =
+                    params[this.route.options.visibleOffLayersKey];
+            }
+            /* This order is important because to control whichever
+             the order of * param. First whe open and close everything.*/
+            if (visibleOnLayersParams === '*') {
+                visible = true;
+            }
+            if (visibleOffLayersParams === '*') {
+                visible = false;
+            }
+            // After, managing named layer by id (context.json OR id from datasource)
+            visiblelayers = visibleOnLayersParams.split(',');
+            invisiblelayers = visibleOffLayersParams.split(',');
+            if (visiblelayers.indexOf(currentLayerid) > -1 || visiblelayers.indexOf(currentLayerid.toString()) > -1) {
+                visible = true;
+            }
+            if (invisiblelayers.indexOf(currentLayerid) > -1 || invisiblelayers.indexOf(currentLayerid.toString()) > -1) {
+                visible = false;
+            }
+        }
+        return visible;
+    }
+}
+LayerContextDirective.ɵfac = function LayerContextDirective_Factory(t) { return new (t || LayerContextDirective)(i0.ɵɵdirectiveInject(i1.MapBrowserComponent), i0.ɵɵdirectiveInject(i2.ContextService), i0.ɵɵdirectiveInject(i1.LayerService), i0.ɵɵdirectiveInject(i3.ConfigService), i0.ɵɵdirectiveInject(i1.StyleListService), i0.ɵɵdirectiveInject(i1.StyleService), i0.ɵɵdirectiveInject(i3.RouteService, 8)); };
+LayerContextDirective.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: LayerContextDirective, selectors: [["", "igoLayerContext", ""]], inputs: { removeLayersOnContextChange: "removeLayersOnContextChange" } });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LayerContextDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[igoLayerContext]'
+            }]
+    }], function () { return [{ type: i1.MapBrowserComponent }, { type: i2.ContextService }, { type: i1.LayerService }, { type: i3.ConfigService }, { type: i1.StyleListService }, { type: i1.StyleService }, { type: i3.RouteService, decorators: [{
+                type: Optional
+            }] }]; }, { removeLayersOnContextChange: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"layer-context.directive.js","sourceRoot":"","sources":["../../../../../../packages/context/src/lib/context-manager/shared/layer-context.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, OnInit, OnDestroy, Optional, Input } from '@angular/core';\n\nimport { Subscription, merge } from 'rxjs';\nimport { buffer, debounceTime, filter } from 'rxjs/operators';\n\nimport { RouteService, ConfigService } from '@igo2/core';\nimport {\n  MapBrowserComponent,\n  Layer,\n  LayerService,\n  LayerOptions,\n  StyleListService,\n  StyleService\n} from '@igo2/geo';\nimport type { IgoMap } from '@igo2/geo';\n\nimport { ContextService } from './context.service';\nimport { DetailedContext } from './context.interface';\nimport {\n  addImportedFeaturesToMap,\n  addImportedFeaturesStyledToMap\n} from '../../context-import-export/shared/context-import.utils';\nimport GeoJSON from 'ol/format/GeoJSON';\n\n@Directive({\n  selector: '[igoLayerContext]'\n})\nexport class LayerContextDirective implements OnInit, OnDestroy {\n  private context$$: Subscription;\n  private queryParams: any;\n\n  private contextLayers: Layer[] = [];\n\n  @Input() removeLayersOnContextChange: boolean = true;\n\n  get map(): IgoMap {\n    return this.component.map;\n  }\n\n  constructor(\n    private component: MapBrowserComponent,\n    private contextService: ContextService,\n    private layerService: LayerService,\n    private configService: ConfigService,\n    private styleListService: StyleListService,\n    private styleService: StyleService,\n    @Optional() private route: RouteService\n  ) {}\n\n  ngOnInit() {\n    this.context$$ = this.contextService.context$\n      .pipe(filter((context) => context !== undefined))\n      .subscribe((context) => this.handleContextChange(context));\n\n    if (\n      this.route &&\n      this.route.options.visibleOnLayersKey &&\n      this.route.options.visibleOffLayersKey &&\n      this.route.options.contextKey\n    ) {\n      const queryParams$$ = this.route.queryParams.subscribe((params) => {\n        if (Object.keys(params).length > 0) {\n          this.queryParams = params;\n          queryParams$$.unsubscribe();\n        }\n      });\n    }\n  }\n\n  ngOnDestroy() {\n    this.context$$.unsubscribe();\n  }\n\n  private handleContextChange(context: DetailedContext) {\n    if (context.layers === undefined) {\n      return;\n    }\n    if (this.removeLayersOnContextChange === true) {\n      this.map.removeAllLayers();\n    } else {\n      this.map.removeLayers(this.contextLayers);\n    }\n    this.contextLayers = [];\n\n    const layersAndIndex$ = merge(\n      ...context.layers.map((layerOptions: LayerOptions, index: number) => {\n        return this.layerService.createAsyncLayer(layerOptions, context.uri);\n      })\n    );\n\n    layersAndIndex$\n      .pipe(buffer(layersAndIndex$.pipe(debounceTime(500))))\n      .subscribe((layers: Layer[]) => {\n        this.handleAddLayers(layers);\n\n        if (context.extraFeatures) {\n          context.extraFeatures.forEach((featureCollection) => {\n            const format = new GeoJSON();\n            const title = featureCollection.name;\n            featureCollection = JSON.stringify(featureCollection);\n            featureCollection = format.readFeatures(featureCollection, {\n              dataProjection: 'EPSG:4326',\n              featureProjection: 'EPSG:3857'\n            });\n            const importExportOptions = this.configService.getConfig('importExport');\n            const importWithStyle =importExportOptions?.importWithStyle || this.configService.getConfig('importWithStyle');\n            if (this.configService.getConfig('importWithStyle')) {\n              console.warn(`\n              The location of this config importWithStyle is deprecated.\n              Please move this property within importExport configuration.\n              Ex: importWithStyle: true/false must be transfered to importExport: { importWithStyle: true/false }\n              Refer to environnement.ts OR config/config.json\n              This legacy conversion will be deleted in 2024.\n              `);\n            }\n            if (!importWithStyle) {\n              addImportedFeaturesToMap(featureCollection, this.map, title);\n            } else {\n              addImportedFeaturesStyledToMap(\n                featureCollection,\n                this.map,\n                title,\n                this.styleListService,\n                this.styleService\n              );\n            }\n          });\n        }\n      });\n\n      this.layerService.createAsyncIdbLayers(context.uri).pipe(debounceTime(500))\n      .subscribe((layers: Layer[]) => this.handleAddLayers(layers));\n\n  }\n\n  private handleAddLayers(layers: Layer[]) {\n    layers = layers\n      .filter((layer: Layer) => layer !== undefined)\n      .map((layer) => {\n        layer.visible = this.computeLayerVisibilityFromUrl(layer);\n        layer.zIndex = layer.zIndex;\n\n        return layer;\n      });\n    this.contextLayers.concat(layers);\n    this.map.addLayers(layers);\n  }\n\n  private computeLayerVisibilityFromUrl(layer: Layer): boolean {\n    const params = this.queryParams;\n    const currentContext = this.contextService.context$.value.uri;\n    const currentLayerid: string = layer.id;\n\n    let visible = layer.visible;\n    if (!params || !currentLayerid) {\n      return visible;\n    }\n\n    const contextParams = params[this.route.options.contextKey as string];\n    if (contextParams === currentContext || !contextParams) {\n      let visibleOnLayersParams = '';\n      let visibleOffLayersParams = '';\n      let visiblelayers: string[] = [];\n      let invisiblelayers: string[] = [];\n\n      if (\n        this.route.options.visibleOnLayersKey &&\n        params[this.route.options.visibleOnLayersKey as string]\n      ) {\n        visibleOnLayersParams =\n          params[this.route.options.visibleOnLayersKey as string];\n      }\n      if (\n        this.route.options.visibleOffLayersKey &&\n        params[this.route.options.visibleOffLayersKey as string]\n      ) {\n        visibleOffLayersParams =\n          params[this.route.options.visibleOffLayersKey as string];\n      }\n\n      /* This order is important because to control whichever\n       the order of * param. First whe open and close everything.*/\n      if (visibleOnLayersParams === '*') {\n        visible = true;\n      }\n      if (visibleOffLayersParams === '*') {\n        visible = false;\n      }\n\n      // After, managing named layer by id (context.json OR id from datasource)\n      visiblelayers = visibleOnLayersParams.split(',');\n      invisiblelayers = visibleOffLayersParams.split(',');\n      if (visiblelayers.indexOf(currentLayerid) > -1 || visiblelayers.indexOf(currentLayerid.toString()) > -1) {\n        visible = true;\n      }\n      if (invisiblelayers.indexOf(currentLayerid) > -1 || invisiblelayers.indexOf(currentLayerid.toString()) > -1) {\n        visible = false;\n      }\n    }\n\n    return visible;\n  }\n}\n"]}

package/esm2020/lib/context-manager/shared/map-context.directive.mjs

@@ -1,70 +1,70 @@
-import { Directive } from '@angular/core';
-import { filter } from 'rxjs/operators';
-import * as i0 from "@angular/core";
-import * as i1 from "@igo2/geo";
-import * as i2 from "./context.service";
-import * as i3 from "@igo2/core";
-export class MapContextDirective {
-    constructor(component, contextService, mediaService) {
-        this.contextService = contextService;
-        this.mediaService = mediaService;
-        this.component = component;
-    }
-    get map() {
-        return this.component.map;
-    }
-    ngOnInit() {
-        this.context$$ = this.contextService.context$
-            .pipe(filter(context => context !== undefined))
-            .subscribe(context => this.handleContextChange(context));
-    }
-    ngOnDestroy() {
-        this.context$$.unsubscribe();
-    }
-    handleContextChange(context) {
-        if (context.map === undefined) {
-            return;
-        }
-        // This creates a new ol.Map when the context changes. Doing that
-        // allows the print tool to work properly even when the map's canvas
-        // has been tainted (CORS) with the layers of another context. This could
-        // have some side effects such as unbinding all listeners on the first map.
-        // A better solution would be to create a new map (preview) before
-        // printing and avoid the tainted canvas issue. This will come later so
-        // this snippet of code is kept here in case it takes too long becomes
-        // an issue
-        // const target = this.component.map.ol.getTarget();
-        // this.component.map.ol.setTarget(undefined);
-        // this.component.map.init();
-        // this.component.map.ol.setTarget(target);
-        const viewContext = context.map.view;
-        if (!this.component.view || viewContext.keepCurrentView !== true || context.map.view.projection !== this.map.projection) {
-            this.component.view = viewContext;
-        }
-        if (this.component.map.geolocationController) {
-            this.component.map.geolocationController.updateGeolocationOptions(viewContext);
-        }
-        const controlsContext = context.map.controls;
-        if (!this.component.controls && controlsContext) {
-            if (this.mediaService.isMobile()) {
-                if (typeof (controlsContext.scaleLine) !== 'boolean') {
-                    const scaleLineOption = controlsContext.scaleLine;
-                    if (!scaleLineOption.minWidth) {
-                        scaleLineOption.minWidth = Math.min(64, scaleLineOption.minWidth);
-                        controlsContext.scaleLine = scaleLineOption;
-                    }
-                }
-            }
-            this.component.controls = controlsContext;
-        }
-    }
-}
-MapContextDirective.ɵfac = function MapContextDirective_Factory(t) { return new (t || MapContextDirective)(i0.ɵɵdirectiveInject(i1.MapBrowserComponent), i0.ɵɵdirectiveInject(i2.ContextService), i0.ɵɵdirectiveInject(i3.MediaService)); };
-MapContextDirective.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: MapContextDirective, selectors: [["", "igoMapContext", ""]] });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MapContextDirective, [{
-        type: Directive,
-        args: [{
-                selector: '[igoMapContext]'
-            }]
-    }], function () { return [{ type: i1.MapBrowserComponent }, { type: i2.ContextService }, { type: i3.MediaService }]; }, null); })();
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwLWNvbnRleHQuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29udGV4dC9zcmMvbGliL2NvbnRleHQtbWFuYWdlci9zaGFyZWQvbWFwLWNvbnRleHQuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQXFCLE1BQU0sZUFBZSxDQUFDO0FBRzdELE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQzs7Ozs7QUFZeEMsTUFBTSxPQUFPLG1CQUFtQjtJQVE5QixZQUNFLFNBQThCLEVBQ3RCLGNBQThCLEVBQzlCLFlBQTBCO1FBRDFCLG1CQUFjLEdBQWQsY0FBYyxDQUFnQjtRQUM5QixpQkFBWSxHQUFaLFlBQVksQ0FBYztRQUVsQyxJQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQztJQUM3QixDQUFDO0lBVkQsSUFBSSxHQUFHO1FBQ0wsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQztJQUM1QixDQUFDO0lBVUQsUUFBUTtRQUNOLElBQUksQ0FBQyxTQUFTLEdBQUcsSUFBSSxDQUFDLGNBQWMsQ0FBQyxRQUFRO2FBQzFDLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxPQUFPLEtBQUssU0FBUyxDQUFDLENBQUM7YUFDOUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLG1CQUFtQixDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7SUFDN0QsQ0FBQztJQUVELFdBQVc7UUFDVCxJQUFJLENBQUMsU0FBUyxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQy9CLENBQUM7SUFFTyxtQkFBbUIsQ0FBQyxPQUF3QjtRQUNsRCxJQUFJLE9BQU8sQ0FBQyxHQUFHLEtBQUssU0FBUyxFQUFFO1lBQzdCLE9BQU87U0FDUjtRQUVELGlFQUFpRTtRQUNqRSxvRUFBb0U7UUFDcEUseUVBQXlFO1FBQ3pFLDJFQUEyRTtRQUMzRSxrRUFBa0U7UUFDbEUsdUVBQXVFO1FBQ3ZFLHNFQUFzRTtRQUN0RSxXQUFXO1FBRVgsb0RBQW9EO1FBQ3BELDhDQUE4QztRQUM5Qyw2QkFBNkI7UUFDN0IsMkNBQTJDO1FBRTNDLE1BQU0sV0FBVyxHQUFtQixPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQztRQUNyRCxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLElBQUksV0FBVyxDQUFDLGVBQWUsS0FBSyxJQUFJLElBQUksT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsVUFBVSxLQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsVUFBVSxFQUFFO1lBQ3ZILElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxHQUFHLFdBQTZCLENBQUM7U0FDckQ7UUFDRCxJQUFJLElBQUksQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLHFCQUFxQixFQUFFO1lBQzVDLElBQUksQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLHFCQUFxQixDQUFDLHdCQUF3QixDQUFDLFdBQVcsQ0FBQyxDQUFDO1NBQ2hGO1FBRUQsTUFBTSxlQUFlLEdBQXVCLE9BQU8sQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDO1FBQ2pFLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsSUFBSSxlQUFlLEVBQUU7WUFDL0MsSUFBSSxJQUFJLENBQUMsWUFBWSxDQUFDLFFBQVEsRUFBRSxFQUFFO2dCQUNoQyxJQUFJLE9BQU0sQ0FBQyxlQUFlLENBQUMsU0FBUyxDQUFDLEtBQUssU0FBUyxFQUFFO29CQUNuRCxNQUFNLGVBQWUsR0FBRyxlQUFlLENBQUMsU0FBZ0MsQ0FBQztvQkFDekUsSUFBSSxDQUFDLGVBQWUsQ0FBQyxRQUFRLEVBQUU7d0JBQzdCLGVBQWUsQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLEVBQUUsZUFBZSxDQUFDLFFBQVEsQ0FBQyxDQUFDO3dCQUNsRSxlQUFlLENBQUMsU0FBUyxHQUFHLGVBQWUsQ0FBQztxQkFDN0M7aUJBQ0Y7YUFDRjtZQUNELElBQUksQ0FBQyxTQUFTLENBQUMsUUFBUSxHQUFHLGVBQWUsQ0FBQztTQUMzQztJQUNILENBQUM7O3NGQWxFVSxtQkFBbUI7c0VBQW5CLG1CQUFtQjt1RkFBbkIsbUJBQW1CO2NBSC9CLFNBQVM7ZUFBQztnQkFDVCxRQUFRLEVBQUUsaUJBQWlCO2FBQzVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBPbkluaXQsIE9uRGVzdHJveSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuaW1wb3J0IHsgU3Vic2NyaXB0aW9uIH0gZnJvbSAncnhqcyc7XHJcbmltcG9ydCB7IGZpbHRlciB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcclxuXHJcbmltcG9ydCB7IE1hcFZpZXdPcHRpb25zLCBNYXBCcm93c2VyQ29tcG9uZW50LCBNYXBDb250cm9sc09wdGlvbnMsIE1hcFNjYWxlTGluZU9wdGlvbnMgfSBmcm9tICdAaWdvMi9nZW8nO1xyXG5pbXBvcnQgdHlwZSB7IElnb01hcCB9IGZyb20gJ0BpZ28yL2dlbyc7XHJcblxyXG5pbXBvcnQgeyBDb250ZXh0U2VydmljZSB9IGZyb20gJy4vY29udGV4dC5zZXJ2aWNlJztcclxuaW1wb3J0IHsgRGV0YWlsZWRDb250ZXh0LCBDb250ZXh0TWFwVmlldyB9IGZyb20gJy4vY29udGV4dC5pbnRlcmZhY2UnO1xyXG5pbXBvcnQgeyBNZWRpYVNlcnZpY2UgfSBmcm9tICdAaWdvMi9jb3JlJztcclxuXHJcbkBEaXJlY3RpdmUoe1xyXG4gIHNlbGVjdG9yOiAnW2lnb01hcENvbnRleHRdJ1xyXG59KVxyXG5leHBvcnQgY2xhc3MgTWFwQ29udGV4dERpcmVjdGl2ZSBpbXBsZW1lbnRzIE9uSW5pdCwgT25EZXN0cm95IHtcclxuICBwcml2YXRlIGNvbXBvbmVudDogTWFwQnJvd3NlckNvbXBvbmVudDtcclxuICBwcml2YXRlIGNvbnRleHQkJDogU3Vic2NyaXB0aW9uO1xyXG5cclxuICBnZXQgbWFwKCk6IElnb01hcCB7XHJcbiAgICByZXR1cm4gdGhpcy5jb21wb25lbnQubWFwO1xyXG4gIH1cclxuXHJcbiAgY29uc3RydWN0b3IoXHJcbiAgICBjb21wb25lbnQ6IE1hcEJyb3dzZXJDb21wb25lbnQsXHJcbiAgICBwcml2YXRlIGNvbnRleHRTZXJ2aWNlOiBDb250ZXh0U2VydmljZSxcclxuICAgIHByaXZhdGUgbWVkaWFTZXJ2aWNlOiBNZWRpYVNlcnZpY2VcclxuICApIHtcclxuICAgIHRoaXMuY29tcG9uZW50ID0gY29tcG9uZW50O1xyXG4gIH1cclxuXHJcbiAgbmdPbkluaXQoKSB7XHJcbiAgICB0aGlzLmNvbnRleHQkJCA9IHRoaXMuY29udGV4dFNlcnZpY2UuY29udGV4dCRcclxuICAgICAgLnBpcGUoZmlsdGVyKGNvbnRleHQgPT4gY29udGV4dCAhPT0gdW5kZWZpbmVkKSlcclxuICAgICAgLnN1YnNjcmliZShjb250ZXh0ID0+IHRoaXMuaGFuZGxlQ29udGV4dENoYW5nZShjb250ZXh0KSk7XHJcbiAgfVxyXG5cclxuICBuZ09uRGVzdHJveSgpIHtcclxuICAgIHRoaXMuY29udGV4dCQkLnVuc3Vic2NyaWJlKCk7XHJcbiAgfVxyXG5cclxuICBwcml2YXRlIGhhbmRsZUNvbnRleHRDaGFuZ2UoY29udGV4dDogRGV0YWlsZWRDb250ZXh0KSB7XHJcbiAgICBpZiAoY29udGV4dC5tYXAgPT09IHVuZGVmaW5lZCkge1xyXG4gICAgICByZXR1cm47XHJcbiAgICB9XHJcblxyXG4gICAgLy8gVGhpcyBjcmVhdGVzIGEgbmV3IG9sLk1hcCB3aGVuIHRoZSBjb250ZXh0IGNoYW5nZXMuIERvaW5nIHRoYXRcclxuICAgIC8vIGFsbG93cyB0aGUgcHJpbnQgdG9vbCB0byB3b3JrIHByb3Blcmx5IGV2ZW4gd2hlbiB0aGUgbWFwJ3MgY2FudmFzXHJcbiAgICAvLyBoYXMgYmVlbiB0YWludGVkIChDT1JTKSB3aXRoIHRoZSBsYXllcnMgb2YgYW5vdGhlciBjb250ZXh0LiBUaGlzIGNvdWxkXHJcbiAgICAvLyBoYXZlIHNvbWUgc2lkZSBlZmZlY3RzIHN1Y2ggYXMgdW5iaW5kaW5nIGFsbCBsaXN0ZW5lcnMgb24gdGhlIGZpcnN0IG1hcC5cclxuICAgIC8vIEEgYmV0dGVyIHNvbHV0aW9uIHdvdWxkIGJlIHRvIGNyZWF0ZSBhIG5ldyBtYXAgKHByZXZpZXcpIGJlZm9yZVxyXG4gICAgLy8gcHJpbnRpbmcgYW5kIGF2b2lkIHRoZSB0YWludGVkIGNhbnZhcyBpc3N1ZS4gVGhpcyB3aWxsIGNvbWUgbGF0ZXIgc29cclxuICAgIC8vIHRoaXMgc25pcHBldCBvZiBjb2RlIGlzIGtlcHQgaGVyZSBpbiBjYXNlIGl0IHRha2VzIHRvbyBsb25nIGJlY29tZXNcclxuICAgIC8vIGFuIGlzc3VlXHJcblxyXG4gICAgLy8gY29uc3QgdGFyZ2V0ID0gdGhpcy5jb21wb25lbnQubWFwLm9sLmdldFRhcmdldCgpO1xyXG4gICAgLy8gdGhpcy5jb21wb25lbnQubWFwLm9sLnNldFRhcmdldCh1bmRlZmluZWQpO1xyXG4gICAgLy8gdGhpcy5jb21wb25lbnQubWFwLmluaXQoKTtcclxuICAgIC8vIHRoaXMuY29tcG9uZW50Lm1hcC5vbC5zZXRUYXJnZXQodGFyZ2V0KTtcclxuXHJcbiAgICBjb25zdCB2aWV3Q29udGV4dDogQ29udGV4dE1hcFZpZXcgPSBjb250ZXh0Lm1hcC52aWV3O1xyXG4gICAgaWYgKCF0aGlzLmNvbXBvbmVudC52aWV3IHx8IHZpZXdDb250ZXh0LmtlZXBDdXJyZW50VmlldyAhPT0gdHJ1ZSB8fCBjb250ZXh0Lm1hcC52aWV3LnByb2plY3Rpb24gIT09IHRoaXMubWFwLnByb2plY3Rpb24pIHtcclxuICAgICAgdGhpcy5jb21wb25lbnQudmlldyA9IHZpZXdDb250ZXh0IGFzIE1hcFZpZXdPcHRpb25zO1xyXG4gICAgfVxyXG4gICAgaWYgKHRoaXMuY29tcG9uZW50Lm1hcC5nZW9sb2NhdGlvbkNvbnRyb2xsZXIpIHtcclxuICAgICAgdGhpcy5jb21wb25lbnQubWFwLmdlb2xvY2F0aW9uQ29udHJvbGxlci51cGRhdGVHZW9sb2NhdGlvbk9wdGlvbnModmlld0NvbnRleHQpO1xyXG4gICAgfVxyXG5cclxuICAgIGNvbnN0IGNvbnRyb2xzQ29udGV4dDogTWFwQ29udHJvbHNPcHRpb25zID0gY29udGV4dC5tYXAuY29udHJvbHM7XHJcbiAgICBpZiAoIXRoaXMuY29tcG9uZW50LmNvbnRyb2xzICYmIGNvbnRyb2xzQ29udGV4dCkge1xyXG4gICAgICBpZiAodGhpcy5tZWRpYVNlcnZpY2UuaXNNb2JpbGUoKSkge1xyXG4gICAgICAgIGlmICh0eXBlb2YoY29udHJvbHNDb250ZXh0LnNjYWxlTGluZSkgIT09ICdib29sZWFuJykge1xyXG4gICAgICAgICAgY29uc3Qgc2NhbGVMaW5lT3B0aW9uID0gY29udHJvbHNDb250ZXh0LnNjYWxlTGluZSBhcyBNYXBTY2FsZUxpbmVPcHRpb25zO1xyXG4gICAgICAgICAgaWYgKCFzY2FsZUxpbmVPcHRpb24ubWluV2lkdGgpIHtcclxuICAgICAgICAgICAgc2NhbGVMaW5lT3B0aW9uLm1pbldpZHRoID0gTWF0aC5taW4oNjQsIHNjYWxlTGluZU9wdGlvbi5taW5XaWR0aCk7XHJcbiAgICAgICAgICAgIGNvbnRyb2xzQ29udGV4dC5zY2FsZUxpbmUgPSBzY2FsZUxpbmVPcHRpb247XHJcbiAgICAgICAgICB9XHJcbiAgICAgICAgfVxyXG4gICAgICB9XHJcbiAgICAgIHRoaXMuY29tcG9uZW50LmNvbnRyb2xzID0gY29udHJvbHNDb250ZXh0O1xyXG4gICAgfVxyXG4gIH1cclxufVxyXG4iXX0=
+import { Directive } from '@angular/core';
+import { filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/geo";
+import * as i2 from "./context.service";
+import * as i3 from "@igo2/core";
+export class MapContextDirective {
+    constructor(component, contextService, mediaService) {
+        this.contextService = contextService;
+        this.mediaService = mediaService;
+        this.component = component;
+    }
+    get map() {
+        return this.component.map;
+    }
+    ngOnInit() {
+        this.context$$ = this.contextService.context$
+            .pipe(filter(context => context !== undefined))
+            .subscribe(context => this.handleContextChange(context));
+    }
+    ngOnDestroy() {
+        this.context$$.unsubscribe();
+    }
+    handleContextChange(context) {
+        if (context.map === undefined) {
+            return;
+        }
+        // This creates a new ol.Map when the context changes. Doing that
+        // allows the print tool to work properly even when the map's canvas
+        // has been tainted (CORS) with the layers of another context. This could
+        // have some side effects such as unbinding all listeners on the first map.
+        // A better solution would be to create a new map (preview) before
+        // printing and avoid the tainted canvas issue. This will come later so
+        // this snippet of code is kept here in case it takes too long becomes
+        // an issue
+        // const target = this.component.map.ol.getTarget();
+        // this.component.map.ol.setTarget(undefined);
+        // this.component.map.init();
+        // this.component.map.ol.setTarget(target);
+        const viewContext = context.map.view;
+        if (!this.component.view || viewContext.keepCurrentView !== true || context.map.view.projection !== this.map.projection) {
+            this.component.view = viewContext;
+        }
+        if (this.component.map.geolocationController) {
+            this.component.map.geolocationController.updateGeolocationOptions(viewContext);
+        }
+        const controlsContext = context.map.controls;
+        if (!this.component.controls && controlsContext) {
+            if (this.mediaService.isMobile()) {
+                if (typeof (controlsContext.scaleLine) !== 'boolean') {
+                    const scaleLineOption = controlsContext.scaleLine;
+                    if (!scaleLineOption.minWidth) {
+                        scaleLineOption.minWidth = Math.min(64, scaleLineOption.minWidth);
+                        controlsContext.scaleLine = scaleLineOption;
+                    }
+                }
+            }
+            this.component.controls = controlsContext;
+        }
+    }
+}
+MapContextDirective.ɵfac = function MapContextDirective_Factory(t) { return new (t || MapContextDirective)(i0.ɵɵdirectiveInject(i1.MapBrowserComponent), i0.ɵɵdirectiveInject(i2.ContextService), i0.ɵɵdirectiveInject(i3.MediaService)); };
+MapContextDirective.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: MapContextDirective, selectors: [["", "igoMapContext", ""]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MapContextDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[igoMapContext]'
+            }]
+    }], function () { return [{ type: i1.MapBrowserComponent }, { type: i2.ContextService }, { type: i3.MediaService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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