@igo2/geo 1.12.1 → 1.13.0-alpha.0

package/esm2020/lib/map/shared/map-pointer-position.directive.mjs

@@ -0,0 +1,107 @@
+import { Directive, Input, Output, EventEmitter, Self } from '@angular/core';
+import { transform } from 'ol/proj';
+import { unByKey } from 'ol/Observable';
+import * as i0 from "@angular/core";
+import * as i1 from "../../map/map-browser/map-browser.component";
+import * as i2 from "@igo2/core";
+/**
+ * This directive return the pointer coordinate (on click or pointermove)
+ * in [longitude, latitude], delayed by in input (pointerMoveDelay)
+ * to avoid too many emitted values.
+ */
+export class PointerPositionDirective {
+    constructor(component, mediaService) {
+        this.component = component;
+        this.mediaService = mediaService;
+        /**
+         * Delay before emitting an event
+         */
+        this.pointerPositionDelay = 1000;
+        /**
+         * Event emitted when the pointer move, delayed by pointerMoveDelay
+         */
+        this.pointerPositionCoord = new EventEmitter();
+    }
+    /**
+     * IGO map
+     * @internal
+     */
+    get map() {
+        return this.component.map;
+    }
+    get mapProjection() {
+        return this.component.map.projection;
+    }
+    /**
+     * Start listening to pointermove
+     * @internal
+     */
+    ngOnInit() {
+        this.listenToMapPointerMove();
+        this.listenToMapClick();
+    }
+    /**
+     * Stop listening to pointermove
+     * @internal
+     */
+    ngOnDestroy() {
+        this.unlistenToMapPointerMove();
+        this.unlistenToMapClick();
+    }
+    /**
+     * On map pointermove
+     */
+    listenToMapPointerMove() {
+        this.pointerMoveListener = this.map.ol.on('pointermove', (event) => this.onPointerEvent(event, this.pointerPositionDelay));
+    }
+    /**
+     * On map click
+     */
+    listenToMapClick() {
+        this.mapClickListener = this.map.ol.on('singleclick', (event) => this.onPointerEvent(event, 0));
+    }
+    /**
+     * Stop listening for map pointermove
+     */
+    unlistenToMapPointerMove() {
+        unByKey(this.pointerMoveListener);
+        this.pointerMoveListener = undefined;
+    }
+    /**
+     * Stop listening for map clicks
+     */
+    unlistenToMapClick() {
+        this.mapClickListener = undefined;
+    }
+    /**
+     * emit delayed coordinate (longitude, latitude array) based on pointerMoveDelay or on click
+     * @param event OL map browser pointer event
+     */
+    onPointerEvent(event, delay) {
+        if (event.dragging || this.mediaService.isTouchScreen()) {
+            return;
+        }
+        if (typeof this.lastTimeoutRequest !== 'undefined') { // cancel timeout when the mouse moves
+            clearTimeout(this.lastTimeoutRequest);
+        }
+        const lonlat = transform(event.coordinate, this.mapProjection, 'EPSG:4326');
+        this.lastTimeoutRequest = setTimeout(() => {
+            this.pointerPositionCoord.emit(lonlat);
+        }, delay);
+    }
+}
+PointerPositionDirective.ɵfac = function PointerPositionDirective_Factory(t) { return new (t || PointerPositionDirective)(i0.ɵɵdirectiveInject(i1.MapBrowserComponent, 2), i0.ɵɵdirectiveInject(i2.MediaService)); };
+PointerPositionDirective.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PointerPositionDirective, selectors: [["", "igoPointerPosition", ""]], inputs: { pointerPositionDelay: "pointerPositionDelay" }, outputs: { pointerPositionCoord: "pointerPositionCoord" } });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PointerPositionDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[igoPointerPosition]'
+            }]
+    }], function () { return [{ type: i1.MapBrowserComponent, decorators: [{
+                type: Self
+            }] }, { type: i2.MediaService }]; }, { pointerPositionDelay: [{
+            type: Input
+        }], pointerPositionCoord: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/map/shared/map.enums.mjs

@@ -0,0 +1,6 @@
+export var MapViewAction;
+(function (MapViewAction) {
+    MapViewAction[MapViewAction["Move"] = 0] = "Move";
+    MapViewAction[MapViewAction["Zoom"] = 1] = "Zoom";
+})(MapViewAction || (MapViewAction = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwLmVudW1zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvbWFwL3NoYXJlZC9tYXAuZW51bXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksYUFHWDtBQUhELFdBQVksYUFBYTtJQUN2QixpREFBSSxDQUFBO0lBQ0osaURBQUksQ0FBQTtBQUNOLENBQUMsRUFIVyxhQUFhLEtBQWIsYUFBYSxRQUd4QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIE1hcFZpZXdBY3Rpb24ge1xyXG4gIE1vdmUsXHJcbiAgWm9vbVxyXG59XHJcbiJdfQ==

package/esm2020/lib/map/shared/map.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/map/shared/map.mjs

@@ -0,0 +1,417 @@
+import olMap from 'ol/Map';
+import olView from 'ol/View';
+import olControlAttribution from 'ol/control/Attribution';
+import olControlScaleLine from 'ol/control/ScaleLine';
+import * as olproj from 'ol/proj';
+import * as olproj4 from 'ol/proj/proj4';
+import * as olinteraction from 'ol/interaction';
+import proj4 from 'proj4';
+import { BehaviorSubject } from 'rxjs';
+import { Overlay } from '../../overlay/shared/overlay';
+import { LayerWatcher } from '../utils/layer-watcher';
+import { MapViewController } from './controllers/view';
+import { MapGeolocationController } from './controllers/geolocation';
+// TODO: This class is messy. Clearly define it's scope and the map browser's.
+// Move some stuff into controllers.
+export class IgoMap {
+    constructor(options, storageService, configService) {
+        this.storageService = storageService;
+        this.configService = configService;
+        this.offlineButtonToggle$ = new BehaviorSubject(false);
+        this.layers$ = new BehaviorSubject([]);
+        this.swipeEnabled$ = new BehaviorSubject(false);
+        this.mapCenter$ = new BehaviorSubject(false);
+        this.selectedFeatures$ = new BehaviorSubject(null);
+        this.defaultOptions = {
+            controls: { attribution: false }
+        };
+        this.options = Object.assign({}, this.defaultOptions, options);
+        this.layerWatcher = new LayerWatcher();
+        this.status$ = this.layerWatcher.status$;
+        olproj4.register(proj4);
+        this.init();
+    }
+    get layers() {
+        return this.layers$.value;
+    }
+    get projection() {
+        return this.viewController.getOlProjection().getCode();
+    }
+    init() {
+        const controls = [];
+        if (this.options.controls) {
+            if (this.options.controls.attribution) {
+                const attributionOpt = (this.options.controls.attribution === true
+                    ? {}
+                    : this.options.controls.attribution);
+                controls.push(new olControlAttribution(attributionOpt));
+            }
+            if (this.options.controls.scaleLine) {
+                const scaleLineOpt = (this.options.controls.scaleLine === true
+                    ? {}
+                    : this.options.controls.scaleLine);
+                controls.push(new olControlScaleLine(scaleLineOpt));
+            }
+        }
+        let interactions = {};
+        if (this.options.interactions === false) {
+            interactions = {
+                altShiftDragRotate: false,
+                doubleClickZoom: false,
+                keyboard: false,
+                mouseWheelZoom: false,
+                shiftDragZoom: false,
+                dragPan: false,
+                pinchRotate: false,
+                pinchZoom: false
+            };
+        }
+        this.ol = new olMap({
+            interactions: olinteraction.defaults(interactions),
+            controls
+        });
+        this.setView(this.options.view || {});
+        this.viewController = new MapViewController({
+            stateHistory: true
+        });
+        this.viewController.setOlMap(this.ol);
+        this.overlay = new Overlay(this);
+        this.queryResultsOverlay = new Overlay(this);
+        this.searchResultsOverlay = new Overlay(this);
+        this.ol.once('rendercomplete', () => {
+            this.geolocationController = new MapGeolocationController(this, {
+                projection: this.viewController.getOlProjection()
+            }, this.storageService, this.configService);
+            this.geolocationController.setOlMap(this.ol);
+            if (this.geolocationController) {
+                this.geolocationController.updateGeolocationOptions(this.mapViewOptions);
+            }
+        });
+    }
+    setTarget(id) {
+        this.ol.setTarget(id);
+        if (id !== undefined) {
+            this.layerWatcher.subscribe(() => { }, null);
+        }
+        else {
+            this.layerWatcher.unsubscribe();
+        }
+    }
+    updateView(options) {
+        const currentView = this.ol.getView();
+        const viewOptions = Object.assign({
+            zoom: currentView.getZoom()
+        }, currentView.getProperties());
+        this.setView(Object.assign(viewOptions, options));
+        if (options.maxZoomOnExtent) {
+            this.viewController.maxZoomOnExtent = options.maxZoomOnExtent;
+        }
+        this.mapViewOptions = options;
+    }
+    /**
+     * Set the map view
+     * @param options Map view options
+     */
+    setView(options) {
+        if (this.viewController !== undefined) {
+            this.viewController.clearStateHistory();
+        }
+        options = Object.assign({ constrainResolution: true }, options);
+        const view = new olView(options);
+        this.ol.setView(view);
+        if (options) {
+            if (options.maxLayerZoomExtent) {
+                this.viewController.maxLayerZoomExtent = options.maxLayerZoomExtent;
+            }
+            if (options.center) {
+                const projection = view.getProjection().getCode();
+                const center = olproj.fromLonLat(options.center, projection);
+                view.setCenter(center);
+            }
+        }
+    }
+    updateControls(value) {
+        if (value === undefined) {
+            return;
+        }
+        const controls = [];
+        if (value.attribution) {
+            const attributionOpt = (value.attribution === true
+                ? {}
+                : value.attribution);
+            controls.push(new olControlAttribution(attributionOpt));
+        }
+        if (value.scaleLine) {
+            const scaleLineOpt = (value.scaleLine === true
+                ? {}
+                : value.scaleLine);
+            controls.push(new olControlScaleLine(scaleLineOpt));
+        }
+        const currentControls = Object.assign([], this.ol.getControls().getArray());
+        currentControls.forEach(control => {
+            this.ol.removeControl(control);
+        });
+        controls.forEach(control => {
+            this.ol.addControl(control);
+        });
+    }
+    /**
+     * Deprecated
+     * TODO: Move to ViewController and update every place it's used
+     */
+    getCenter(projection) {
+        return this.viewController.getCenter(projection);
+    }
+    /**
+     * Deprecated
+     * TODO: Move to ViewController and update every place it's used
+     */
+    getExtent(projection) {
+        return this.viewController.getExtent(projection);
+    }
+    // TODO: Move to ViewController and update every place it's used
+    getZoom() {
+        return this.viewController.getZoom();
+    }
+    changeBaseLayer(baseLayer) {
+        if (!baseLayer) {
+            return;
+        }
+        for (const bl of this.getBaseLayers()) {
+            bl.visible = false;
+        }
+        baseLayer.visible = true;
+        this.viewController.olView.setMinZoom(baseLayer.dataSource.options.minZoom || (this.options.view || {}).minZoom);
+        this.viewController.olView.setMaxZoom(baseLayer.dataSource.options.maxZoom || (this.options.view || {}).maxZoom);
+    }
+    getBaseLayers() {
+        return this.layers.filter((layer) => layer.baseLayer === true);
+    }
+    getLayerById(id) {
+        return this.layers.find((layer) => layer.id && layer.id === id);
+    }
+    getLayerByAlias(alias) {
+        return this.layers.find((layer) => layer.alias && layer.alias === alias);
+    }
+    getLayerByOlUId(olUId) {
+        return this.layers.find((layer) => layer.ol.ol_uid && layer.ol.ol_uid === olUId);
+    }
+    /**
+     * Add a single layer
+     * @param layer Layer to add
+     * @param push DEPRECATED
+     */
+    addLayer(layer, push = true) {
+        this.addLayers([layer]);
+    }
+    /**
+     * Add many layers
+     * @param layers Layers to add
+     * @param push DEPRECATED
+     */
+    addLayers(layers, push = true) {
+        let offsetZIndex = 0;
+        let offsetBaseLayerZIndex = 0;
+        const addedLayers = layers
+            .map((layer) => {
+            if (!layer) {
+                return;
+            }
+            const offset = layer.zIndex
+                ? 0
+                : layer.baseLayer
+                    ? offsetBaseLayerZIndex++
+                    : offsetZIndex++;
+            return this.doAddLayer(layer, offset);
+        })
+            .filter((layer) => layer !== undefined);
+        this.setLayers([].concat(this.layers, addedLayers));
+    }
+    /**
+     * Remove a single layer
+     * @param layer Layer to remove
+     */
+    removeLayer(layer) {
+        this.removeLayers([layer]);
+    }
+    /**
+     * Remove many layers
+     * @param layers Layers to remove
+     */
+    removeLayers(layers) {
+        const newLayers = this.layers$.value.slice(0);
+        const layersToRemove = [];
+        layers.forEach((layer) => {
+            const index = newLayers.indexOf(layer);
+            if (index >= 0) {
+                layersToRemove.push(layer);
+                newLayers.splice(index, 1);
+                this.handleLinkedLayersDeletion(layer, layersToRemove);
+                layersToRemove.map(linkedLayer => {
+                    layersToRemove.push(linkedLayer);
+                    const linkedIndex = newLayers.indexOf(linkedLayer);
+                    if (linkedIndex >= 0) {
+                        newLayers.splice(linkedIndex, 1);
+                    }
+                });
+            }
+        });
+        layersToRemove.forEach((layer) => this.doRemoveLayer(layer));
+        this.setLayers(newLayers);
+    }
+    /**
+     * Build a list of linked layers to delete
+     * @param srcLayer Layer that has triggered the deletion
+     * @param layersToRemove list to append the layer to delete into
+     */
+    handleLinkedLayersDeletion(srcLayer, layersToRemove) {
+        const linkedLayers = srcLayer.options.linkedLayers;
+        if (!linkedLayers) {
+            return;
+        }
+        const currentLinkedId = linkedLayers.linkId;
+        const currentLinks = linkedLayers.links;
+        const isParentLayer = currentLinks ? true : false;
+        if (isParentLayer) {
+            // search for child layers
+            currentLinks.map(link => {
+                if (!link.syncedDelete) {
+                    return;
+                }
+                link.linkedIds.map(linkedId => {
+                    const layerToApply = this.layers.find(layer => layer.options.linkedLayers?.linkId === linkedId);
+                    if (layerToApply) {
+                        layersToRemove.push(layerToApply);
+                    }
+                });
+            });
+        }
+        else {
+            // search for parent layer
+            this.layers.map(layer => {
+                if (layer.options.linkedLayers?.links) {
+                    layer.options.linkedLayers.links.map(l => {
+                        if (l.syncedDelete && l.bidirectionnal !== false &&
+                            l.linkedIds.indexOf(currentLinkedId) !== -1) {
+                            layersToRemove.push(layer);
+                            this.handleLinkedLayersDeletion(layer, layersToRemove);
+                        }
+                    });
+                }
+            });
+        }
+    }
+    /**
+     * Remove all layers
+     */
+    removeAllLayers() {
+        this.layers.forEach((layer) => this.doRemoveLayer(layer));
+        this.layers$.next([]);
+    }
+    raiseLayer(layer) {
+        const index = this.getLayerIndex(layer);
+        if (index > 1) {
+            this.moveLayer(layer, index, index - 1);
+        }
+    }
+    raiseLayers(layers) {
+        for (const layer of layers) {
+            this.raiseLayer(layer);
+        }
+    }
+    lowerLayer(layer) {
+        const index = this.getLayerIndex(layer);
+        if (index < this.layers.length - 1) {
+            this.moveLayer(layer, index, index + 1);
+        }
+    }
+    lowerLayers(layers) {
+        const reverseLayers = layers.reverse();
+        for (const layer of reverseLayers) {
+            this.lowerLayer(layer);
+        }
+    }
+    moveLayer(layer, from, to) {
+        const layerTo = this.layers[to];
+        const zIndexTo = layerTo.zIndex;
+        const zIndexFrom = layer.zIndex;
+        if (layerTo.baseLayer || layer.baseLayer) {
+            return;
+        }
+        layer.zIndex = zIndexTo;
+        layerTo.zIndex = zIndexFrom;
+        this.layers[to] = layer;
+        this.layers[from] = layerTo;
+        this.layers$.next(this.layers.slice(0));
+    }
+    /**
+     * Add a layer to the OL map and start watching. If the layer is already
+     * added to this map, make it visible but don't add it one again.
+     * @param layer Layer
+     * @returns The layer added, if any
+     */
+    doAddLayer(layer, offsetZIndex) {
+        if (layer.baseLayer && layer.visible) {
+            this.changeBaseLayer(layer);
+        }
+        const existingLayer = this.getLayerById(layer.id);
+        if (existingLayer !== undefined) {
+            existingLayer.visible = true;
+            return;
+        }
+        if (!layer.baseLayer && layer.zIndex) {
+            layer.zIndex += 10;
+        }
+        if (layer.zIndex === undefined || layer.zIndex === 0) {
+            const maxZIndex = Math.max(layer.baseLayer ? 0 : 10, ...this.layers
+                .filter((l) => l.baseLayer === layer.baseLayer && l.zIndex < 200 // zIndex > 200 = system layer
+            )
+                .map((l) => l.zIndex));
+            layer.zIndex = maxZIndex + 1 + offsetZIndex;
+        }
+        if (layer.baseLayer && layer.zIndex > 9) {
+            layer.zIndex = 10; // baselayer must have zIndex < 10
+        }
+        layer.setMap(this);
+        this.layerWatcher.watchLayer(layer);
+        this.ol.addLayer(layer.ol);
+        return layer;
+    }
+    /**
+     * Remove a layer from the OL map and stop watching
+     * @param layer Layer
+     */
+    doRemoveLayer(layer) {
+        this.layerWatcher.unwatchLayer(layer);
+        this.ol.removeLayer(layer.ol);
+        layer.setMap(undefined);
+    }
+    /**
+     * Update the layers observable
+     * @param layers Layers
+     */
+    setLayers(layers) {
+        this.layers$.next(this.sortLayersByZIndex(layers).slice(0));
+    }
+    /**
+     * Sort layers by descending zIndex
+     * @param layers Array of layers
+     * @returns The original array, sorted by zIndex
+     */
+    sortLayersByZIndex(layers) {
+        // Sort by descending zIndex
+        return layers.sort((layer1, layer2) => layer2.zIndex - layer1.zIndex);
+    }
+    /**
+     * Get layer index in the map's inenr array of layers
+     * @param layer Layer
+     * @returns The layer index
+     */
+    getLayerIndex(layer) {
+        return this.layers.findIndex((_layer) => _layer === layer);
+    }
+    onOfflineToggle(offline) {
+        this.offlineButtonToggle$.next(offline);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/map/shared/map.ts"],"names":[],"mappings":"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","sourcesContent":["import olMap from 'ol/Map';\r\nimport olView from 'ol/View';\r\nimport olControlAttribution from 'ol/control/Attribution';\r\nimport olControlScaleLine from 'ol/control/ScaleLine';\r\nimport * as olproj from 'ol/proj';\r\nimport * as olproj4 from 'ol/proj/proj4';\r\nimport OlProjection from 'ol/proj/Projection';\r\nimport * as olinteraction from 'ol/interaction';\r\n\r\nimport proj4 from 'proj4';\r\nimport { BehaviorSubject, Subject } from 'rxjs';\r\n\r\nimport { SubjectStatus } from '@igo2/utils';\r\n\r\nimport { Layer } from '../../layer/shared/layers';\r\nimport { Overlay } from '../../overlay/shared/overlay';\r\n\r\nimport { LayerWatcher } from '../utils/layer-watcher';\r\nimport {\r\n  MapViewOptions,\r\n  MapOptions,\r\n  MapAttributionOptions,\r\n  MapScaleLineOptions,\r\n  MapExtent,\r\n  MapControlsOptions\r\n} from './map.interface';\r\nimport { MapViewController } from './controllers/view';\r\nimport { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';\r\nimport { MapGeolocationController } from './controllers/geolocation';\r\nimport { StorageService, ConfigService } from '@igo2/core';\r\n\r\n// TODO: This class is messy. Clearly define it's scope and the map browser's.\r\n// Move some stuff into controllers.\r\nexport class IgoMap {\r\n  public ol: olMap;\r\n  public offlineButtonToggle$ = new BehaviorSubject<boolean>(false);\r\n  public layers$ = new BehaviorSubject<Layer[]>([]);\r\n  public status$: Subject<SubjectStatus>;\r\n  public overlay: Overlay;\r\n  public queryResultsOverlay: Overlay;\r\n  public searchResultsOverlay: Overlay;\r\n  public viewController: MapViewController;\r\n  public geolocationController: MapGeolocationController;\r\n  public swipeEnabled$ = new BehaviorSubject<boolean>(false);\r\n  public mapCenter$ = new BehaviorSubject<boolean>(false);\r\n  public selectedFeatures$ = new BehaviorSubject<Layer[]>(null);\r\n\r\n  public bufferDataSource: FeatureDataSource;\r\n\r\n  private layerWatcher: LayerWatcher;\r\n\r\n  private options: MapOptions;\r\n  private mapViewOptions: MapViewOptions;\r\n  private defaultOptions: Partial<MapOptions> = {\r\n    controls: { attribution: false }\r\n  };\r\n\r\n  get layers(): Layer[] {\r\n    return this.layers$.value;\r\n  }\r\n\r\n  get projection(): string {\r\n    return this.viewController.getOlProjection().getCode();\r\n  }\r\n\r\n  constructor(\r\n    options?: MapOptions,\r\n    private storageService?: StorageService,\r\n    private configService?: ConfigService) {\r\n    this.options = Object.assign({}, this.defaultOptions, options);\r\n    this.layerWatcher = new LayerWatcher();\r\n    this.status$ = this.layerWatcher.status$;\r\n    olproj4.register(proj4);\r\n    this.init();\r\n  }\r\n\r\n  init() {\r\n    const controls = [];\r\n    if (this.options.controls) {\r\n      if (this.options.controls.attribution) {\r\n        const attributionOpt = (this.options.controls.attribution === true\r\n          ? {}\r\n          : this.options.controls.attribution) as MapAttributionOptions;\r\n        controls.push(new olControlAttribution(attributionOpt));\r\n      }\r\n      if (this.options.controls.scaleLine) {\r\n        const scaleLineOpt = (this.options.controls.scaleLine === true\r\n          ? {}\r\n          : this.options.controls.scaleLine) as MapScaleLineOptions;\r\n        controls.push(new olControlScaleLine(scaleLineOpt));\r\n      }\r\n    }\r\n    let interactions = {};\r\n    if (this.options.interactions === false) {\r\n      interactions = {\r\n        altShiftDragRotate: false,\r\n        doubleClickZoom: false,\r\n        keyboard: false,\r\n        mouseWheelZoom: false,\r\n        shiftDragZoom: false,\r\n        dragPan: false,\r\n        pinchRotate: false,\r\n        pinchZoom: false\r\n      };\r\n    }\r\n\r\n    this.ol = new olMap({\r\n      interactions: olinteraction.defaults(interactions),\r\n      controls\r\n    });\r\n\r\n    this.setView(this.options.view || {});\r\n    this.viewController = new MapViewController({\r\n      stateHistory: true\r\n    });\r\n    this.viewController.setOlMap(this.ol);\r\n    this.overlay = new Overlay(this);\r\n    this.queryResultsOverlay = new Overlay(this);\r\n    this.searchResultsOverlay = new Overlay(this);\r\n    this.ol.once('rendercomplete', () => {\r\n      this.geolocationController = new MapGeolocationController(\r\n        this,\r\n        {\r\n          projection: this.viewController.getOlProjection()\r\n        },\r\n        this.storageService,\r\n        this.configService);\r\n      this.geolocationController.setOlMap(this.ol);\r\n      if (this.geolocationController) {\r\n        this.geolocationController.updateGeolocationOptions(this.mapViewOptions);\r\n      }\r\n  });\r\n  }\r\n\r\n  setTarget(id: string) {\r\n    this.ol.setTarget(id);\r\n    if (id !== undefined) {\r\n      this.layerWatcher.subscribe(() => { }, null);\r\n    } else {\r\n      this.layerWatcher.unsubscribe();\r\n    }\r\n  }\r\n\r\n  updateView(options: MapViewOptions) {\r\n    const currentView = this.ol.getView();\r\n    const viewOptions = Object.assign(\r\n      {\r\n        zoom: currentView.getZoom()\r\n      },\r\n      currentView.getProperties()\r\n    );\r\n\r\n    this.setView(Object.assign(viewOptions, options));\r\n    if (options.maxZoomOnExtent) {\r\n      this.viewController.maxZoomOnExtent = options.maxZoomOnExtent;\r\n    }\r\n    this.mapViewOptions = options;\r\n  }\r\n\r\n  /**\r\n   * Set the map view\r\n   * @param options Map view options\r\n   */\r\n  setView(options: MapViewOptions) {\r\n    if (this.viewController !== undefined) {\r\n      this.viewController.clearStateHistory();\r\n    }\r\n\r\n    options = Object.assign({ constrainResolution: true }, options);\r\n    const view = new olView(options);\r\n    this.ol.setView(view);\r\n\r\n    if (options) {\r\n      if (options.maxLayerZoomExtent) {\r\n        this.viewController.maxLayerZoomExtent = options.maxLayerZoomExtent;\r\n      }\r\n\r\n      if (options.center) {\r\n        const projection = view.getProjection().getCode();\r\n        const center = olproj.fromLonLat(options.center, projection);\r\n        view.setCenter(center);\r\n      }\r\n    }\r\n  }\r\n\r\n  updateControls(value: MapControlsOptions) {\r\n    if (value === undefined) {\r\n      return;\r\n    }\r\n\r\n    const controls = [];\r\n    if (value.attribution) {\r\n      const attributionOpt = (value.attribution === true\r\n        ? {}\r\n        : value.attribution) as MapAttributionOptions;\r\n      controls.push(new olControlAttribution(attributionOpt));\r\n    }\r\n    if (value.scaleLine) {\r\n      const scaleLineOpt = (value.scaleLine === true\r\n        ? {}\r\n        : value.scaleLine) as MapScaleLineOptions;\r\n      controls.push(new olControlScaleLine(scaleLineOpt));\r\n    }\r\n\r\n    const currentControls = Object.assign([], this.ol.getControls().getArray());\r\n    currentControls.forEach(control => {\r\n      this.ol.removeControl(control);\r\n    });\r\n    controls.forEach(control => {\r\n      this.ol.addControl(control);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Deprecated\r\n   * TODO: Move to ViewController and update every place it's used\r\n   */\r\n  getCenter(projection?: string | OlProjection): [number, number] {\r\n    return this.viewController.getCenter(projection);\r\n  }\r\n\r\n  /**\r\n   * Deprecated\r\n   * TODO: Move to ViewController and update every place it's used\r\n   */\r\n  getExtent(projection?: string | OlProjection): MapExtent {\r\n    return this.viewController.getExtent(projection);\r\n  }\r\n\r\n  // TODO: Move to ViewController and update every place it's used\r\n  getZoom(): number {\r\n    return this.viewController.getZoom();\r\n  }\r\n\r\n  changeBaseLayer(baseLayer: Layer) {\r\n    if (!baseLayer) {\r\n      return;\r\n    }\r\n\r\n    for (const bl of this.getBaseLayers()) {\r\n      bl.visible = false;\r\n    }\r\n\r\n    baseLayer.visible = true;\r\n\r\n    this.viewController.olView.setMinZoom(\r\n      baseLayer.dataSource.options.minZoom || (this.options.view || {}).minZoom\r\n    );\r\n    this.viewController.olView.setMaxZoom(\r\n      baseLayer.dataSource.options.maxZoom || (this.options.view || {}).maxZoom\r\n    );\r\n  }\r\n\r\n  getBaseLayers(): Layer[] {\r\n    return this.layers.filter((layer: Layer) => layer.baseLayer === true);\r\n  }\r\n\r\n  getLayerById(id: string): Layer {\r\n    return this.layers.find((layer: Layer) => layer.id && layer.id === id);\r\n  }\r\n\r\n  getLayerByAlias(alias: string): Layer {\r\n    return this.layers.find(\r\n      (layer: Layer) => layer.alias && layer.alias === alias\r\n    );\r\n  }\r\n\r\n  getLayerByOlUId(olUId: string): Layer {\r\n    return this.layers.find(\r\n      (layer: Layer) => (layer.ol as any).ol_uid && (layer.ol as any).ol_uid === olUId\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Add a single layer\r\n   * @param layer Layer to add\r\n   * @param push DEPRECATED\r\n   */\r\n  addLayer(layer: Layer, push = true) {\r\n    this.addLayers([layer]);\r\n  }\r\n\r\n  /**\r\n   * Add many layers\r\n   * @param layers Layers to add\r\n   * @param push DEPRECATED\r\n   */\r\n  addLayers(layers: Layer[], push = true) {\r\n    let offsetZIndex = 0;\r\n    let offsetBaseLayerZIndex = 0;\r\n    const addedLayers = layers\r\n      .map((layer: Layer) => {\r\n        if (!layer) { return; }\r\n        const offset = layer.zIndex\r\n          ? 0\r\n          : layer.baseLayer\r\n            ? offsetBaseLayerZIndex++\r\n            : offsetZIndex++;\r\n        return this.doAddLayer(layer, offset);\r\n      })\r\n      .filter((layer: Layer | undefined) => layer !== undefined);\r\n    this.setLayers([].concat(this.layers, addedLayers));\r\n  }\r\n\r\n  /**\r\n   * Remove a single layer\r\n   * @param layer Layer to remove\r\n   */\r\n  removeLayer(layer: Layer) {\r\n    this.removeLayers([layer]);\r\n  }\r\n\r\n  /**\r\n   * Remove many layers\r\n   * @param layers Layers to remove\r\n   */\r\n  removeLayers(layers: Layer[]) {\r\n    const newLayers = this.layers$.value.slice(0);\r\n    const layersToRemove = [];\r\n    layers.forEach((layer: Layer) => {\r\n      const index = newLayers.indexOf(layer);\r\n      if (index >= 0) {\r\n        layersToRemove.push(layer);\r\n        newLayers.splice(index, 1);\r\n        this.handleLinkedLayersDeletion(layer, layersToRemove);\r\n        layersToRemove.map(linkedLayer => {\r\n          layersToRemove.push(linkedLayer);\r\n          const linkedIndex = newLayers.indexOf(linkedLayer);\r\n          if (linkedIndex >= 0) {\r\n            newLayers.splice(linkedIndex, 1);\r\n          }\r\n        });\r\n      }\r\n    });\r\n\r\n    layersToRemove.forEach((layer: Layer) => this.doRemoveLayer(layer));\r\n    this.setLayers(newLayers);\r\n  }\r\n\r\n  /**\r\n   * Build a list of linked layers to delete\r\n   * @param srcLayer Layer that has triggered the deletion\r\n   * @param layersToRemove list to append the layer to delete into\r\n   */\r\n  handleLinkedLayersDeletion(srcLayer: Layer, layersToRemove: Layer[]) {\r\n    const linkedLayers = srcLayer.options.linkedLayers;\r\n    if (!linkedLayers) {\r\n      return;\r\n    }\r\n    const currentLinkedId = linkedLayers.linkId;\r\n    const currentLinks = linkedLayers.links;\r\n    const isParentLayer = currentLinks ? true : false;\r\n    if (isParentLayer) {\r\n      // search for child layers\r\n      currentLinks.map(link => {\r\n        if (!link.syncedDelete) {\r\n          return;\r\n        }\r\n        link.linkedIds.map(linkedId => {\r\n          const layerToApply = this.layers.find(layer => layer.options.linkedLayers?.linkId === linkedId);\r\n          if (layerToApply) {\r\n            layersToRemove.push(layerToApply);\r\n          }\r\n        });\r\n      });\r\n    } else {\r\n      // search for parent layer\r\n      this.layers.map(layer => {\r\n        if (layer.options.linkedLayers?.links) {\r\n          layer.options.linkedLayers.links.map(l => {\r\n            if (\r\n              l.syncedDelete && l.bidirectionnal !== false &&\r\n              l.linkedIds.indexOf(currentLinkedId) !== -1) {\r\n              layersToRemove.push(layer);\r\n              this.handleLinkedLayersDeletion(layer, layersToRemove);\r\n            }\r\n          });\r\n        }\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Remove all layers\r\n   */\r\n  removeAllLayers() {\r\n    this.layers.forEach((layer: Layer) => this.doRemoveLayer(layer));\r\n    this.layers$.next([]);\r\n  }\r\n\r\n  raiseLayer(layer: Layer) {\r\n    const index = this.getLayerIndex(layer);\r\n    if (index > 1) {\r\n      this.moveLayer(layer, index, index - 1);\r\n    }\r\n  }\r\n\r\n  raiseLayers(layers: Layer[]) {\r\n    for (const layer of layers) {\r\n      this.raiseLayer(layer);\r\n    }\r\n  }\r\n\r\n  lowerLayer(layer: Layer) {\r\n    const index = this.getLayerIndex(layer);\r\n    if (index < this.layers.length - 1) {\r\n      this.moveLayer(layer, index, index + 1);\r\n    }\r\n  }\r\n\r\n  lowerLayers(layers: Layer[]) {\r\n    const reverseLayers = layers.reverse();\r\n    for (const layer of reverseLayers) {\r\n      this.lowerLayer(layer);\r\n    }\r\n  }\r\n\r\n  moveLayer(layer: Layer, from: number, to: number) {\r\n    const layerTo = this.layers[to];\r\n    const zIndexTo = layerTo.zIndex;\r\n    const zIndexFrom = layer.zIndex;\r\n\r\n    if (layerTo.baseLayer || layer.baseLayer) {\r\n      return;\r\n    }\r\n\r\n    layer.zIndex = zIndexTo;\r\n    layerTo.zIndex = zIndexFrom;\r\n\r\n    this.layers[to] = layer;\r\n    this.layers[from] = layerTo;\r\n    this.layers$.next(this.layers.slice(0));\r\n  }\r\n\r\n  /**\r\n   * Add a layer to the OL map and start watching. If the layer is already\r\n   * added to this map, make it visible but don't add it one again.\r\n   * @param layer Layer\r\n   * @returns The layer added, if any\r\n   */\r\n  private doAddLayer(layer: Layer, offsetZIndex: number) {\r\n    if (layer.baseLayer && layer.visible) {\r\n      this.changeBaseLayer(layer);\r\n    }\r\n\r\n    const existingLayer = this.getLayerById(layer.id);\r\n    if (existingLayer !== undefined) {\r\n      existingLayer.visible = true;\r\n      return;\r\n    }\r\n\r\n    if (!layer.baseLayer && layer.zIndex) {\r\n      layer.zIndex += 10;\r\n    }\r\n\r\n    if (layer.zIndex === undefined || layer.zIndex === 0) {\r\n      const maxZIndex = Math.max(\r\n        layer.baseLayer ? 0 : 10,\r\n        ...this.layers\r\n          .filter(\r\n            (l) => l.baseLayer === layer.baseLayer && l.zIndex < 200 // zIndex > 200 = system layer\r\n          )\r\n          .map((l) => l.zIndex)\r\n      );\r\n      layer.zIndex = maxZIndex + 1 + offsetZIndex;\r\n    }\r\n\r\n    if (layer.baseLayer && layer.zIndex > 9) {\r\n      layer.zIndex = 10; // baselayer must have zIndex < 10\r\n    }\r\n\r\n    layer.setMap(this);\r\n    this.layerWatcher.watchLayer(layer);\r\n    this.ol.addLayer(layer.ol);\r\n\r\n    return layer;\r\n  }\r\n\r\n  /**\r\n   * Remove a layer from the OL map and stop watching\r\n   * @param layer Layer\r\n   */\r\n  private doRemoveLayer(layer: Layer) {\r\n    this.layerWatcher.unwatchLayer(layer);\r\n    this.ol.removeLayer(layer.ol);\r\n    layer.setMap(undefined);\r\n  }\r\n\r\n  /**\r\n   * Update the layers observable\r\n   * @param layers Layers\r\n   */\r\n  private setLayers(layers: Layer[]) {\r\n    this.layers$.next(this.sortLayersByZIndex(layers).slice(0));\r\n  }\r\n\r\n  /**\r\n   * Sort layers by descending zIndex\r\n   * @param layers Array of layers\r\n   * @returns The original array, sorted by zIndex\r\n   */\r\n  private sortLayersByZIndex(layers: Layer[]) {\r\n    // Sort by descending zIndex\r\n    return layers.sort(\r\n      (layer1: Layer, layer2: Layer) => layer2.zIndex - layer1.zIndex\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Get layer index in the map's inenr array of layers\r\n   * @param layer Layer\r\n   * @returns The layer index\r\n   */\r\n  private getLayerIndex(layer: Layer) {\r\n    return this.layers.findIndex((_layer: Layer) => _layer === layer);\r\n  }\r\n\r\n  onOfflineToggle(offline: boolean) {\r\n    this.offlineButtonToggle$.next(offline);\r\n  }\r\n}\r\n"]}

package/esm2020/lib/map/shared/map.service.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * MapService
+ *
+ * This service tracks the IgoMap instance, if any.
+ * Currently, only one map instance is supported
+ * but support for multiple maps may be added in the future.
+ * This will impact other services such as the OverlayService
+ * because these maps won't be sharing overlayed features.
+ */
+export class MapService {
+    constructor() { }
+    getMap() {
+        return this.map;
+    }
+    setMap(map) {
+        this.map = map;
+    }
+}
+MapService.ɵfac = function MapService_Factory(t) { return new (t || MapService)(); };
+MapService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: MapService, factory: MapService.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MapService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return []; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9tYXAvc2hhcmVkL21hcC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSTNDOzs7Ozs7OztHQVFHO0FBSUgsTUFBTSxPQUFPLFVBQVU7SUFHckIsZ0JBQWUsQ0FBQztJQUVoQixNQUFNO1FBQ0osT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDO0lBQ2xCLENBQUM7SUFFRCxNQUFNLENBQUMsR0FBVztRQUNoQixJQUFJLENBQUMsR0FBRyxHQUFHLEdBQUcsQ0FBQztJQUNqQixDQUFDOztvRUFYVSxVQUFVO2dFQUFWLFVBQVUsV0FBVixVQUFVLG1CQUZULE1BQU07dUZBRVAsVUFBVTtjQUh0QixVQUFVO2VBQUM7Z0JBQ1YsVUFBVSxFQUFFLE1BQU07YUFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5pbXBvcnQgeyBJZ29NYXAgfSBmcm9tICcuL21hcCc7XHJcblxyXG4vKipcclxuICogTWFwU2VydmljZVxyXG4gKlxyXG4gKiBUaGlzIHNlcnZpY2UgdHJhY2tzIHRoZSBJZ29NYXAgaW5zdGFuY2UsIGlmIGFueS5cclxuICogQ3VycmVudGx5LCBvbmx5IG9uZSBtYXAgaW5zdGFuY2UgaXMgc3VwcG9ydGVkXHJcbiAqIGJ1dCBzdXBwb3J0IGZvciBtdWx0aXBsZSBtYXBzIG1heSBiZSBhZGRlZCBpbiB0aGUgZnV0dXJlLlxyXG4gKiBUaGlzIHdpbGwgaW1wYWN0IG90aGVyIHNlcnZpY2VzIHN1Y2ggYXMgdGhlIE92ZXJsYXlTZXJ2aWNlXHJcbiAqIGJlY2F1c2UgdGhlc2UgbWFwcyB3b24ndCBiZSBzaGFyaW5nIG92ZXJsYXllZCBmZWF0dXJlcy5cclxuICovXHJcbkBJbmplY3RhYmxlKHtcclxuICBwcm92aWRlZEluOiAncm9vdCdcclxufSlcclxuZXhwb3J0IGNsYXNzIE1hcFNlcnZpY2Uge1xyXG4gIHByaXZhdGUgbWFwOiBJZ29NYXA7XHJcblxyXG4gIGNvbnN0cnVjdG9yKCkge31cclxuXHJcbiAgZ2V0TWFwKCk6IElnb01hcCB7XHJcbiAgICByZXR1cm4gdGhpcy5tYXA7XHJcbiAgfVxyXG5cclxuICBzZXRNYXAobWFwOiBJZ29NYXApIHtcclxuICAgIHRoaXMubWFwID0gbWFwO1xyXG4gIH1cclxufVxyXG4iXX0=