@igo2/geo 1.12.1 → 1.13.0-alpha.0

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

@@ -0,0 +1,163 @@
+import { Directive } from '@angular/core';
+import { ClusterDataSource } from '../../datasource/shared/datasources/cluster-datasource';
+import { MVTDataSource } from '../../datasource/shared/datasources/mvt-datasource';
+import { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';
+import { XYZDataSource } from '../../datasource/shared/datasources/xyz-datasource';
+import * as i0 from "@angular/core";
+import * as i1 from "../map-browser/map-browser.component";
+import * as i2 from "@igo2/core";
+export class MapOfflineDirective {
+    constructor(component, networkService, messageService, languageService) {
+        this.networkService = networkService;
+        this.messageService = messageService;
+        this.languageService = languageService;
+        this.offlineButtonStatus = false;
+        this.networkState = {
+            connection: true
+        };
+        this.offlineButtonState = {
+            connection: true
+        };
+        this.component = component;
+    }
+    get map() {
+        return this.component.map;
+    }
+    ngAfterViewInit() {
+        this.map.offlineButtonToggle$.subscribe((offlineButtonToggle) => {
+            if (this.previousMessageId) {
+                this.messageService.remove(this.previousMessageId);
+            }
+            this.offlineButtonStatus = offlineButtonToggle;
+            const translate = this.languageService.translate;
+            if (this.offlineButtonStatus && this.networkState.connection) {
+                const message = translate.instant('igo.geo.network.offline.message');
+                const title = translate.instant('igo.geo.network.offline.title');
+                const messageObj = this.messageService.info(message, title);
+                this.previousMessageId = messageObj.toastId;
+                this.offlineButtonState.connection = false;
+                this.changeLayer();
+            }
+            else if (!this.offlineButtonStatus && !this.networkState.connection) {
+                const message = translate.instant('igo.geo.network.offline.message');
+                const title = translate.instant('igo.geo.network.offline.title');
+                const messageObj = this.messageService.info(message, title);
+                this.previousMessageId = messageObj.toastId;
+                this.offlineButtonState.connection = false;
+                this.changeLayer();
+            }
+            else if (!this.offlineButtonStatus && this.networkState.connection) {
+                let message;
+                let title;
+                const messageObs = translate.get('igo.geo.network.online.message');
+                const titleObs = translate.get('igo.geo.network.online.title');
+                messageObs.subscribe((message1) => {
+                    message = message1;
+                });
+                titleObs.subscribe((title1) => {
+                    title = title1;
+                });
+                if (message) {
+                    const messageObj = this.messageService.info(message, title);
+                    this.previousMessageId = messageObj.toastId;
+                }
+                this.offlineButtonState.connection = true;
+                this.changeLayer();
+            }
+        });
+        this.networkService.currentState().subscribe((state) => {
+            this.networkState = state;
+            if (!this.offlineButtonStatus) {
+                this.changeLayer();
+            }
+        });
+        this.map.layers$.subscribe((layers) => {
+            this.changeLayer();
+        });
+    }
+    changeLayer() {
+        let sourceOptions;
+        const layerList = this.map.layers$.value;
+        layerList.forEach(layer => {
+            if (layer.isIgoInternalLayer) {
+                return;
+            }
+            if (layer.options.source instanceof MVTDataSource) {
+                sourceOptions = layer.options.sourceOptions;
+                layer.ol.getSource().refresh();
+            }
+            else if (layer.options.source instanceof XYZDataSource) {
+                sourceOptions = layer.options.sourceOptions;
+            }
+            else if (layer.options.source instanceof ClusterDataSource) {
+                sourceOptions = layer.options.sourceOptions;
+            }
+            else if (layer.options.source instanceof FeatureDataSource) {
+                sourceOptions = layer.options.sourceOptions;
+            }
+            else {
+                if (this.networkState.connection === false ||
+                    this.offlineButtonState.connection === false) {
+                    layer.ol.setMaxResolution(0);
+                    return;
+                }
+                else if (this.networkState.connection === true ||
+                    this.offlineButtonState.connection === true) {
+                    layer.ol.setMaxResolution(Infinity);
+                    return;
+                }
+            }
+            if (sourceOptions) {
+                if ((sourceOptions.pathOffline &&
+                    this.networkState.connection === false) ||
+                    (sourceOptions.pathOffline &&
+                        this.offlineButtonState.connection === false)) {
+                    if (sourceOptions.type === 'vector' ||
+                        sourceOptions.type === 'cluster') {
+                        return;
+                    }
+                    layer.ol.getSource().setUrl(sourceOptions.pathOffline);
+                }
+                else if ((sourceOptions.pathOffline &&
+                    this.networkState.connection === false) ||
+                    (sourceOptions.pathOffline &&
+                        this.offlineButtonState.connection === true)) {
+                    if (sourceOptions.type === 'vector' ||
+                        sourceOptions.type === 'cluster') {
+                        return;
+                    }
+                    layer.ol.getSource().setUrl(sourceOptions.url);
+                }
+                else {
+                    if (this.networkState.connection === false ||
+                        this.offlineButtonState.connection === false) {
+                        layer.ol.setMaxResolution(0);
+                    }
+                    else if (this.networkState.connection === true ||
+                        this.offlineButtonState.connection === true) {
+                        layer.ol.setMaxResolution(Infinity);
+                    }
+                }
+            }
+            else {
+                if (this.networkState.connection === false ||
+                    this.offlineButtonState.connection === false) {
+                    layer.ol.setMaxResolution(0);
+                }
+                else if (this.networkState.connection === true ||
+                    this.offlineButtonState.connection === true) {
+                    layer.ol.setMaxResolution(Infinity);
+                }
+            }
+        });
+    }
+}
+MapOfflineDirective.ɵfac = function MapOfflineDirective_Factory(t) { return new (t || MapOfflineDirective)(i0.ɵɵdirectiveInject(i1.MapBrowserComponent), i0.ɵɵdirectiveInject(i2.NetworkService), i0.ɵɵdirectiveInject(i2.MessageService), i0.ɵɵdirectiveInject(i2.LanguageService)); };
+MapOfflineDirective.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: MapOfflineDirective, selectors: [["", "igoMapOffline", ""]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MapOfflineDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[igoMapOffline]'
+            }]
+    }], function () { return [{ type: i1.MapBrowserComponent }, { type: i2.NetworkService }, { type: i2.MessageService }, { type: i2.LanguageService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mapOffline.directive.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/map/shared/mapOffline.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, AfterViewInit } from '@angular/core';\r\nimport {\r\n  NetworkService,\r\n  ConnectionState,\r\n  MessageService,\r\n  LanguageService\r\n} from '@igo2/core';\r\n\r\nimport { IgoMap } from './map';\r\nimport { MapBrowserComponent } from '../map-browser/map-browser.component';\r\nimport { FeatureDataSourceOptions } from '../../datasource/shared/datasources/feature-datasource.interface';\r\nimport { XYZDataSourceOptions } from '../../datasource/shared/datasources/xyz-datasource.interface';\r\nimport { MVTDataSourceOptions } from '../../datasource/shared/datasources/mvt-datasource.interface';\r\nimport { ClusterDataSourceOptions } from '../../datasource/shared/datasources/cluster-datasource.interface';\r\nimport { Layer } from '../../layer/shared/layers/layer';\r\nimport { ClusterDataSource } from '../../datasource/shared/datasources/cluster-datasource';\r\nimport { MVTDataSource } from '../../datasource/shared/datasources/mvt-datasource';\r\nimport { FeatureDataSource } from '../../datasource/shared/datasources/feature-datasource';\r\nimport { XYZDataSource } from '../../datasource/shared/datasources/xyz-datasource';\r\n\r\n@Directive({\r\n  selector: '[igoMapOffline]'\r\n})\r\nexport class MapOfflineDirective implements AfterViewInit {\r\n  private component: MapBrowserComponent;\r\n  private offlineButtonStatus: boolean = false;\r\n  private networkState: ConnectionState = {\r\n    connection: true\r\n  };\r\n  private offlineButtonState: ConnectionState = {\r\n    connection: true\r\n  };\r\n\r\n  get map(): IgoMap {\r\n    return this.component.map;\r\n  }\r\n\r\n  private previousMessageId;\r\n\r\n  constructor(\r\n    component: MapBrowserComponent,\r\n    private networkService: NetworkService,\r\n    private messageService: MessageService,\r\n    private languageService: LanguageService\r\n  ) {\r\n    this.component = component;\r\n  }\r\n\r\n  ngAfterViewInit() {\r\n    this.map.offlineButtonToggle$.subscribe((offlineButtonToggle: boolean) => {\r\n      if (this.previousMessageId) {\r\n        this.messageService.remove(this.previousMessageId);\r\n      }\r\n      this.offlineButtonStatus = offlineButtonToggle;\r\n      const translate = this.languageService.translate;\r\n      if (this.offlineButtonStatus && this.networkState.connection) {\r\n        const message = translate.instant('igo.geo.network.offline.message');\r\n        const title = translate.instant('igo.geo.network.offline.title');\r\n        const messageObj = this.messageService.info(message, title);\r\n        this.previousMessageId = messageObj.toastId;\r\n        this.offlineButtonState.connection = false;\r\n        this.changeLayer();\r\n      } else if (!this.offlineButtonStatus && !this.networkState.connection) {\r\n        const message = translate.instant('igo.geo.network.offline.message');\r\n        const title = translate.instant('igo.geo.network.offline.title');\r\n        const messageObj = this.messageService.info(message, title);\r\n        this.previousMessageId = messageObj.toastId;\r\n        this.offlineButtonState.connection = false;\r\n        this.changeLayer();\r\n      } else if (!this.offlineButtonStatus && this.networkState.connection) {\r\n        let message;\r\n        let title;\r\n        const messageObs = translate.get('igo.geo.network.online.message');\r\n        const titleObs = translate.get('igo.geo.network.online.title');\r\n        messageObs.subscribe((message1: string) => {\r\n          message = message1;\r\n        });\r\n        titleObs.subscribe((title1: string) => {\r\n          title = title1;\r\n        });\r\n        if (message) {\r\n          const messageObj = this.messageService.info(message, title);\r\n          this.previousMessageId = messageObj.toastId;\r\n        }\r\n        this.offlineButtonState.connection = true;\r\n        this.changeLayer();\r\n      }\r\n    });\r\n\r\n    this.networkService.currentState().subscribe((state: ConnectionState) => {\r\n      this.networkState = state;\r\n      if (!this.offlineButtonStatus) {\r\n        this.changeLayer();\r\n      }\r\n    });\r\n\r\n    this.map.layers$.subscribe((layers: Layer[]) => {\r\n      this.changeLayer();\r\n    });\r\n  }\r\n\r\n  private changeLayer() {\r\n    let sourceOptions;\r\n    const layerList = this.map.layers$.value;\r\n    layerList.forEach(layer => {\r\n      if (layer.isIgoInternalLayer) {\r\n        return;\r\n      }\r\n      if (layer.options.source instanceof MVTDataSource) {\r\n        sourceOptions = layer.options.sourceOptions as MVTDataSourceOptions;\r\n        layer.ol.getSource().refresh();\r\n      } else if (layer.options.source instanceof XYZDataSource) {\r\n        sourceOptions = layer.options.sourceOptions as XYZDataSourceOptions;\r\n      } else if (layer.options.source instanceof ClusterDataSource) {\r\n        sourceOptions = layer.options.sourceOptions as ClusterDataSourceOptions;\r\n      } else if (layer.options.source instanceof FeatureDataSource) {\r\n        sourceOptions = layer.options.sourceOptions as FeatureDataSourceOptions;\r\n      } else {\r\n        if (\r\n          this.networkState.connection === false ||\r\n          this.offlineButtonState.connection === false\r\n        ) {\r\n          layer.ol.setMaxResolution(0);\r\n          return;\r\n        } else if (\r\n          this.networkState.connection === true ||\r\n          this.offlineButtonState.connection === true\r\n        ) {\r\n          layer.ol.setMaxResolution(Infinity);\r\n          return;\r\n        }\r\n      }\r\n\r\n      if (sourceOptions) {\r\n        if (\r\n          (sourceOptions.pathOffline &&\r\n            this.networkState.connection === false) ||\r\n          (sourceOptions.pathOffline &&\r\n            this.offlineButtonState.connection === false)\r\n        ) {\r\n          if (\r\n            sourceOptions.type === 'vector' ||\r\n            sourceOptions.type === 'cluster'\r\n          ) {\r\n            return;\r\n          }\r\n          (layer.ol.getSource() as any).setUrl(sourceOptions.pathOffline);\r\n        } else if (\r\n          (sourceOptions.pathOffline &&\r\n            this.networkState.connection === false) ||\r\n          (sourceOptions.pathOffline &&\r\n            this.offlineButtonState.connection === true)\r\n        ) {\r\n          if (\r\n            sourceOptions.type === 'vector' ||\r\n            sourceOptions.type === 'cluster'\r\n          ) {\r\n            return;\r\n          }\r\n          (layer.ol.getSource() as any).setUrl(sourceOptions.url);\r\n        } else {\r\n          if (\r\n            this.networkState.connection === false ||\r\n            this.offlineButtonState.connection === false\r\n          ) {\r\n            layer.ol.setMaxResolution(0);\r\n          } else if (\r\n            this.networkState.connection === true ||\r\n            this.offlineButtonState.connection === true\r\n          ) {\r\n            layer.ol.setMaxResolution(Infinity);\r\n          }\r\n        }\r\n      } else {\r\n        if (\r\n          this.networkState.connection === false ||\r\n          this.offlineButtonState.connection === false\r\n        ) {\r\n          layer.ol.setMaxResolution(0);\r\n        } else if (\r\n          this.networkState.connection === true ||\r\n          this.offlineButtonState.connection === true\r\n        ) {\r\n          layer.ol.setMaxResolution(Infinity);\r\n        }\r\n      }\r\n    });\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvamVjdGlvbi5pbnRlcmZhY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvbWFwL3NoYXJlZC9wcm9qZWN0aW9uLmludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgUHJvamVjdGlvbiB7XHJcbiAgYWxpYXM/OiBzdHJpbmc7XHJcbiAgY29kZTogc3RyaW5nO1xyXG4gIGRlZjogc3RyaW5nO1xyXG4gIGV4dGVudDogW251bWJlciwgbnVtYmVyLCBudW1iZXIsIG51bWJlcl07XHJcbn1cclxuZXhwb3J0IGludGVyZmFjZSBJbnB1dFByb2plY3Rpb25zIHtcclxuICB0cmFuc2xhdGVLZXk/OiBzdHJpbmc7XHJcbiAgdHJhbnNsYXRlZFZhbHVlPzogc3RyaW5nO1xyXG4gIGFsaWFzOiBzdHJpbmc7XHJcbiAgY29kZTogc3RyaW5nO1xyXG4gIHpvbmU6IHN0cmluZztcclxufVxyXG5leHBvcnQgaW50ZXJmYWNlIFByb2plY3Rpb25zTGltaXRhdGlvbnNPcHRpb25zIHtcclxuICBwcm9qRnJvbUNvbmZpZz86IGJvb2xlYW47XHJcbiAgbmFkODM/OiBib29sZWFuO1xyXG4gIHdnczg0PzogYm9vbGVhbjtcclxuICB3ZWJNZXJjYXRvcj86IGJvb2xlYW47XHJcbiAgdXRtPzogYm9vbGVhbjtcclxuICBtdG0/OiBib29sZWFuO1xyXG4gIHV0bVpvbmU/OiB7XHJcbiAgICBtaW5ab25lPzogbnVtYmVyLFxyXG4gICAgbWF4Wm9uZT86IG51bWJlclxyXG4gIH07XHJcbiAgbXRtWm9uZT86IHtcclxuICAgIG1pblpvbmU/OiBudW1iZXIsXHJcbiAgICBtYXhab25lPzogbnVtYmVyXHJcbiAgfTtcclxufVxyXG4iXX0=

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

@@ -0,0 +1,65 @@
+import { Injectable } from '@angular/core';
+import proj4 from 'proj4';
+import * as olproj from 'ol/proj';
+import * as olproj4 from 'ol/proj/proj4';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core";
+/**
+ * When injected, this service automatically registers and
+ * projection defined in the application config. A custom projection
+ * needs to be registered to be usable by OL.
+ */
+export class ProjectionService {
+    constructor(config) {
+        this.config = config;
+        const projections = this.config.getConfig('projections') || [];
+        projections.forEach((projection) => {
+            projection.alias = projection.alias ? projection.alias : projection.code;
+            this.registerProjection(projection);
+        });
+        // register all utm zones
+        for (let utmZone = 1; utmZone < 61; utmZone++) {
+            const code = utmZone < 10 ? `EPSG:3260${utmZone}` : `EPSG:326${utmZone}`;
+            const def = `+proj=utm +zone=${utmZone} +datum=WGS84 +units=m +no_defs`;
+            const proj = { code, def, extent: undefined };
+            this.registerProjection(proj);
+        }
+        // register all mtm zones
+        for (let mtmZone = 1; mtmZone < 11; mtmZone++) {
+            const code = mtmZone < 10 ? `EPSG:3218${mtmZone}` : `EPSG:321${80 + mtmZone}`;
+            let lon0;
+            if (Number(mtmZone) <= 2) {
+                lon0 = -50 - Number(mtmZone) * 3;
+            }
+            else if (Number(mtmZone) >= 12) {
+                lon0 = -81 - (Number(mtmZone) - 12) * 3;
+            }
+            else {
+                lon0 = -49.5 - Number(mtmZone) * 3;
+            }
+            const def = `+proj=tmerc +lat_0=0 +lon_0=${lon0} +k=0.9999 +x_0=304800 +y_0=0 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs"`;
+            const proj = { code, def, extent: undefined };
+            this.registerProjection(proj);
+        }
+    }
+    /**
+     * Define a proj4 projection and register it in OL
+     * @param projection Projection
+     */
+    registerProjection(projection) {
+        proj4.defs(projection.code, projection.def);
+        olproj4.register(proj4);
+        if (projection.extent) {
+            olproj.get(projection.code).setExtent(projection.extent);
+        }
+    }
+}
+ProjectionService.ɵfac = function ProjectionService_Factory(t) { return new (t || ProjectionService)(i0.ɵɵinject(i1.ConfigService)); };
+ProjectionService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ProjectionService, factory: ProjectionService.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ProjectionService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.ConfigService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,64 @@
+/**
+ * Return a number of zone MTM for a longitude for province of Quebec only
+ * @param lon number
+ * @returns zone
+ */
+export function zoneMtm(lon) {
+    let lonMin = -54;
+    const lonMax = -81;
+    if (lon < lonMax || lon > lonMin) {
+        return 0;
+    }
+    else {
+        const deltaLon = 3;
+        let zone = 2;
+        while (Math.abs(lon - lonMin) > deltaLon) {
+            lonMin = lonMin - deltaLon;
+            zone++;
+        }
+        return zone;
+    }
+}
+/**
+ * Return a number of zone UTM for a longitude
+ * @param lon number
+ * @returns zone
+ */
+export function zoneUtm(lon) {
+    let lonMin = -180;
+    const lonMax = 180;
+    const deltaLon = 6;
+    let zone = 1;
+    while (Math.abs(lon - lonMin) > deltaLon) {
+        lonMin = lonMin + deltaLon;
+        zone++;
+    }
+    return zone;
+}
+/**
+ * Compute the contraints of projections
+ * @param projectionsLimitations: ProjectionsLimitationsOptions
+ * @returns projectionsContraints: ProjectionsLimitationsOptions
+ */
+export function computeProjectionsConstraints(projectionsLimitations) {
+    const mtmZone = projectionsLimitations.mtmZone;
+    const utmZone = projectionsLimitations.utmZone;
+    const projectionsConstraints = {
+        projFromConfig: projectionsLimitations.projFromConfig === false ? false : true,
+        nad83: projectionsLimitations.nad83 === false ? false : true,
+        wgs84: projectionsLimitations.wgs84 === false ? false : true,
+        webMercator: projectionsLimitations.webMercator === false ? false : true,
+        utm: projectionsLimitations.utm === false ? false : true,
+        mtm: projectionsLimitations.mtm === false ? false : true,
+        utmZone: {
+            minZone: utmZone && utmZone.minZone ? utmZone.minZone : 17,
+            maxZone: utmZone && utmZone.maxZone ? utmZone.maxZone : 21,
+        },
+        mtmZone: {
+            minZone: mtmZone && mtmZone.minZone ? mtmZone.minZone : 2,
+            maxZone: mtmZone && mtmZone.maxZone ? mtmZone.maxZone : 10,
+        }
+    };
+    return projectionsConstraints;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/map/swipe-control/index.mjs

@@ -0,0 +1,2 @@
+export * from './swipe-control.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9tYXAvc3dpcGUtY29udHJvbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zd2lwZS1jb250cm9sLmNvbXBvbmVudCc7XHJcbiJdfQ==

package/esm2020/lib/map/swipe-control/swipe-control.component.mjs

@@ -0,0 +1,193 @@
+import { Component, Input } from '@angular/core';
+import { getRenderPixel } from 'ol/render';
+import * as i0 from "@angular/core";
+/**
+ * Tool to swipe the layers
+ */
+export class SwipeControlComponent {
+    constructor() {
+        /**
+         * State of draggable action
+         */
+        this.inDragAction = false;
+        /**
+         * Binder of prerender on the same element
+         */
+        this.boundPrerender = this.prerender.bind(this);
+    }
+    /**
+     * Get the list of layers for swipe and activate of deactivate the swipe
+     * @internal
+     */
+    ngAfterViewInit() {
+        this.getListOfLayers();
+        this.swipeEnabled$$ = this.map.swipeEnabled$.subscribe(value => {
+            value ? this.displaySwipe() : this.displaySwipeOff();
+        });
+        this.letZoom();
+    }
+    /**
+     * Clear the overlay layer and any interaction added by this component.
+     * @internal
+     */
+    ngOnDestroy() {
+        this.swipeEnabled$$.unsubscribe();
+        this.map.swipeEnabled$.unsubscribe();
+        this.displaySwipeOff();
+    }
+    /**
+     * Display a swipe-element and render the layers
+     */
+    displaySwipe() {
+        this.swipeId.style.visibility = 'visible';
+        this.layers.map(layer => layer.ol.on('prerender', this.boundPrerender));
+        this.layers.map(layer => layer.ol.on('postrender', this.postrender));
+        this.map.ol.render();
+    }
+    /**
+     * Clear a swipe-element and render the layers on the initial state
+     */
+    displaySwipeOff() {
+        this.swipeId.style.visibility = 'hidden';
+        this.layers.map(layer => layer.ol.un('prerender', this.boundPrerender));
+        this.layers.map(layer => layer.ol.un('postrender', this.postrender));
+        this.map.ol.render();
+        this.layers = [];
+    }
+    /**
+     * Getter of element
+     */
+    get swipeId() {
+        return document.getElementById('igo-layer-swipe');
+    }
+    /**
+     * Get the list of layers for swipe
+     */
+    getListOfLayers() {
+        this.map.selectedFeatures$.subscribe(layers => {
+            this.layers = [];
+            if (layers !== null) {
+                for (const layer of layers) {
+                    if (!this.layers.includes(layer)) {
+                        this.layers.push(layer);
+                    }
+                }
+            }
+        });
+    }
+    /**
+     * Get a position of click or touch
+     */
+    dragDown(event) {
+        this.inDragAction = true;
+        event.preventDefault();
+        if (event.type === 'mousedown') {
+            this.pos3 = event.clientX;
+            this.mouseSwipe();
+            document.onmouseup = this.closeDragMouseElement;
+        }
+        else if (event.type === 'touchstart') {
+            document.getElementById('arrows').style.visibility = 'hidden';
+            this.pos3 = event.touches[0].clientX;
+            this.touchSwipe();
+            document.ontouchend = this.closeDragTouchElement;
+        }
+    }
+    /**
+     * Moving a line with a mouse
+     */
+    mouseSwipe() {
+        document.addEventListener('mousemove', event => {
+            if (this.inDragAction) {
+                event.preventDefault();
+                this.pos1 = this.pos3 - event.clientX;
+                this.pos3 = event.clientX;
+                this.swipeId.style.left = (this.swipeId.offsetLeft - this.pos1) + 'px';
+            }
+            this.map.ol.render();
+        });
+    }
+    /**
+     * Moving a line with a touch
+     */
+    touchSwipe() {
+        document.addEventListener('touchmove', event => {
+            if (this.inDragAction) {
+                event.preventDefault();
+                document.getElementById('arrows').style.visibility = 'hidden';
+                this.pos1 = this.pos3 - event.changedTouches[0].clientX;
+                this.pos3 = event.changedTouches[0].clientX;
+                this.swipeId.style.left = (this.swipeId.offsetLeft - this.pos1) + 'px';
+            }
+            this.map.ol.render();
+        });
+    }
+    /**
+     * Deactivate a listener of a mouse-action
+     */
+    closeDragMouseElement() {
+        document.onmouseup = null;
+        document.onmousemove = null;
+        this.inDragAction = false;
+    }
+    /**
+     * Deactivate a listener of a touch-action
+     */
+    closeDragTouchElement() {
+        document.ontouchend = null;
+        document.ontouchmove = null;
+        document.getElementById('arrows').style.visibility = 'visible';
+        this.inDragAction = false;
+    }
+    /**
+     * Cut the image of a layer by the position of swiped-element
+     */
+    prerender(event) {
+        const ctx = event.context;
+        const mapSize = this.map.ol.getSize();
+        const width = this.swipeId.offsetLeft;
+        const tl = getRenderPixel(event, [width, 0]);
+        const tr = getRenderPixel(event, [0, 0]);
+        const bl = getRenderPixel(event, [width, mapSize[1]]);
+        const br = getRenderPixel(event, [0, mapSize[1]]);
+        ctx.save();
+        ctx.beginPath();
+        ctx.moveTo(tl[0], tl[1]);
+        ctx.lineTo(bl[0], bl[1]);
+        ctx.lineTo(br[0], br[1]);
+        ctx.lineTo(tr[0], tr[1]);
+        ctx.closePath();
+        ctx.clip();
+    }
+    /**
+     * Save a current state of the context
+     */
+    postrender(event) {
+        event.context.restore();
+        event.context.save();
+    }
+    /**
+     * Zoom on div
+     */
+    letZoom() {
+        document.getElementById('igo-layer-swipe').addEventListener('wheel', event => {
+            event.deltaY > 0 ? this.map.viewController.zoomOut() : this.map.viewController.zoomIn();
+        }, true);
+    }
+}
+SwipeControlComponent.ɵfac = function SwipeControlComponent_Factory(t) { return new (t || SwipeControlComponent)(); };
+SwipeControlComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: SwipeControlComponent, selectors: [["igo-swipe-control"]], inputs: { map: "map" }, decls: 5, vars: 0, consts: [["id", "igo-layer-swipe", 1, "igo-swipe-control-container", 3, "mousedown", "mouseup", "touchstart", "touchend"], [1, "igo-swipe-control-line"], ["id", "arrows", 1, "igo-swipe-control-arrows"], [1, "igo-arrow-left"], [1, "igo-arrow-right"]], template: function SwipeControlComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "div", 0);
+        i0.ɵɵlistener("mousedown", function SwipeControlComponent_Template_div_mousedown_0_listener($event) { return ctx.dragDown($event); })("mouseup", function SwipeControlComponent_Template_div_mouseup_0_listener() { return ctx.closeDragMouseElement(); })("touchstart", function SwipeControlComponent_Template_div_touchstart_0_listener($event) { return ctx.dragDown($event); })("touchend", function SwipeControlComponent_Template_div_touchend_0_listener() { return ctx.closeDragTouchElement(); });
+        i0.ɵɵelement(1, "div", 1);
+        i0.ɵɵelementStart(2, "div", 2);
+        i0.ɵɵelement(3, "div", 3)(4, "div", 4);
+        i0.ɵɵelementEnd()();
+    } }, styles: [".igo-swipe-control-container[_ngcontent-%COMP%]{position:absolute;width:80px;height:100%;top:0%;left:50%;cursor:-webkit-grab;cursor:grab;z-index:1;transform:translate(-40px)}.igo-swipe-control-container[_ngcontent-%COMP%]:active{cursor:-webkit-grabbing;cursor:grabbing}.igo-swipe-control-line[_ngcontent-%COMP%]{position:absolute;width:4px;height:100%;top:50%;left:50%;transform:translate(-50%,-50%);background-color:#5e5a5a}.igo-swipe-control-arrows[_ngcontent-%COMP%]{position:absolute;width:32px;height:32px;left:50%;top:50%;transform:translate(-50%,-50%);margin-top:-16px;padding:5px 4px;background-color:#5e5a5a;z-index:2;-webkit-tap-highlight-color:rgba(0,0,0,0)}.igo-swipe-control-arrows[_ngcontent-%COMP%]   div[_ngcontent-%COMP%]{display:inline-block;width:0;height:0;border-top:10px solid transparent;border-bottom:10px solid transparent}.igo-swipe-control-arrows[_ngcontent-%COMP%]   .igo-arrow-right[_ngcontent-%COMP%]{margin-left:4px;border-left:10px solid white}.igo-swipe-control-arrows[_ngcontent-%COMP%]   .igo-arrow-left[_ngcontent-%COMP%]{border-right:10px solid white}.igo-swipe-control-arrows[_ngcontent-%COMP%]:active{display:none}"] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SwipeControlComponent, [{
+        type: Component,
+        args: [{ selector: 'igo-swipe-control', template: "<div class=\"igo-swipe-control-container\"  id=\"igo-layer-swipe\"\r\n  (mousedown)=\"dragDown($event)\"\r\n  (mouseup)=\"closeDragMouseElement()\"\r\n  (touchstart)=\"dragDown($event)\"\r\n  (touchend)=\"closeDragTouchElement()\">\r\n  <div class=\"igo-swipe-control-line\" ></div>\r\n  \r\n  <div class=\"igo-swipe-control-arrows\" id=\"arrows\">\r\n    <div class=\"igo-arrow-left\"></div>\r\n    <div class=\"igo-arrow-right\"></div>\r\n  </div>\r\n</div>\r\n", styles: [".igo-swipe-control-container{position:absolute;width:80px;height:100%;top:0%;left:50%;cursor:-webkit-grab;cursor:grab;z-index:1;transform:translate(-40px)}.igo-swipe-control-container:active{cursor:-webkit-grabbing;cursor:grabbing}.igo-swipe-control-line{position:absolute;width:4px;height:100%;top:50%;left:50%;transform:translate(-50%,-50%);background-color:#5e5a5a}.igo-swipe-control-arrows{position:absolute;width:32px;height:32px;left:50%;top:50%;transform:translate(-50%,-50%);margin-top:-16px;padding:5px 4px;background-color:#5e5a5a;z-index:2;-webkit-tap-highlight-color:rgba(0,0,0,0)}.igo-swipe-control-arrows div{display:inline-block;width:0;height:0;border-top:10px solid transparent;border-bottom:10px solid transparent}.igo-swipe-control-arrows .igo-arrow-right{margin-left:4px;border-left:10px solid white}.igo-swipe-control-arrows .igo-arrow-left{border-right:10px solid white}.igo-swipe-control-arrows:active{display:none}\n"] }]
+    }], function () { return []; }, { map: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"swipe-control.component.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/map/swipe-control/swipe-control.component.ts","../../../../../../packages/geo/src/lib/map/swipe-control/swipe-control.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, AfterViewInit, OnDestroy } from '@angular/core';\r\nimport { Layer } from '../../layer';\r\nimport { IgoMap } from '../shared/map';\r\nimport { getRenderPixel } from 'ol/render';\r\nimport { Subscription } from 'rxjs';\r\n\r\n/**\r\n * Tool to swipe the layers\r\n */\r\n@Component({\r\n  selector: 'igo-swipe-control',\r\n  templateUrl: './swipe-control.component.html',\r\n  styleUrls: ['./swipe-control.component.scss']\r\n})\r\n\r\nexport class SwipeControlComponent implements AfterViewInit, OnDestroy {\r\n\r\n\r\n  /**\r\n   * Get an active map\r\n   */\r\n  @Input() map: IgoMap;\r\n\r\n  /**\r\n   * The list of layers for swipe\r\n   */\r\n  private layers: Layer[];\r\n\r\n  /**\r\n   * Final position of the swiped element\r\n   */\r\n  private pos1: number;\r\n\r\n  /**\r\n   * Intermediate position of the swiped element\r\n   */\r\n  private pos3: number;\r\n\r\n  /**\r\n   * State of draggable action\r\n   */\r\n  private inDragAction: boolean = false;\r\n\r\n  /**\r\n   * Listener of toggle from advanced-map-tool\r\n   */\r\n  private swipeEnabled$$: Subscription;\r\n\r\n  /**\r\n   * Binder of prerender on the same element\r\n   */\r\n  private boundPrerender = this.prerender.bind(this);\r\n\r\n  constructor() {\r\n   }\r\n\r\n  /**\r\n   * Get the list of layers for swipe and activate of deactivate the swipe\r\n   * @internal\r\n   */\r\n  ngAfterViewInit(): void {\r\n    this.getListOfLayers();\r\n    this.swipeEnabled$$ = this.map.swipeEnabled$.subscribe(value => {\r\n        value ? this.displaySwipe() : this.displaySwipeOff();\r\n      });\r\n    this.letZoom();\r\n  }\r\n\r\n  /**\r\n   * Clear the overlay layer and any interaction added by this component.\r\n   * @internal\r\n   */\r\n  ngOnDestroy(): void {\r\n    this.swipeEnabled$$.unsubscribe();\r\n    this.map.swipeEnabled$.unsubscribe();\r\n    this.displaySwipeOff();\r\n  }\r\n\r\n  /**\r\n   * Display a swipe-element and render the layers\r\n   */\r\n  displaySwipe() {\r\n    this.swipeId.style.visibility = 'visible';\r\n    this.layers.map(layer => layer.ol.on('prerender', this.boundPrerender));\r\n    this.layers.map(layer => layer.ol.on('postrender', this.postrender));\r\n    this.map.ol.render();\r\n  }\r\n\r\n  /**\r\n   * Clear a swipe-element and render the layers on the initial state\r\n   */\r\n  displaySwipeOff() {\r\n    this.swipeId.style.visibility = 'hidden';\r\n    this.layers.map(layer => layer.ol.un('prerender', this.boundPrerender));\r\n    this.layers.map(layer => layer.ol.un('postrender', this.postrender));\r\n    this.map.ol.render();\r\n    this.layers = [];\r\n  }\r\n\r\n  /**\r\n   * Getter of element\r\n   */\r\n  get swipeId() {\r\n    return document.getElementById('igo-layer-swipe');\r\n  }\r\n\r\n  /**\r\n   * Get the list of layers for swipe\r\n   */\r\n  getListOfLayers() {\r\n    this.map.selectedFeatures$.subscribe(layers => {\r\n      this.layers = [];\r\n      if (layers !== null) {\r\n        for (const layer of layers) {\r\n          if (!this.layers.includes(layer)) {\r\n            this.layers.push(layer);\r\n          }\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Get a position of click or touch\r\n   */\r\n  dragDown(event) {\r\n    this.inDragAction = true;\r\n    event.preventDefault();\r\n    if (event.type === 'mousedown'){\r\n        this.pos3 = event.clientX;\r\n        this.mouseSwipe();\r\n        document.onmouseup = this.closeDragMouseElement;\r\n    }\r\n    else if (event.type === 'touchstart'){\r\n        document.getElementById('arrows').style.visibility = 'hidden';\r\n        this.pos3 = event.touches[0].clientX;\r\n        this.touchSwipe();\r\n        document.ontouchend = this.closeDragTouchElement;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Moving a line with a mouse\r\n   */\r\n  mouseSwipe(){\r\n    document.addEventListener('mousemove', event => {\r\n      if (this.inDragAction){\r\n        event.preventDefault();\r\n        this.pos1 = this.pos3 - event.clientX;\r\n        this.pos3 = event.clientX;\r\n        this.swipeId.style.left = (this.swipeId.offsetLeft - this.pos1) + 'px';\r\n      }\r\n      this.map.ol.render();\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Moving a line with a touch\r\n   */\r\n  touchSwipe(){\r\n    document.addEventListener('touchmove', event => {\r\n      if (this.inDragAction) {\r\n        event.preventDefault();\r\n        document.getElementById('arrows').style.visibility = 'hidden';\r\n        this.pos1 = this.pos3 - event.changedTouches[0].clientX;\r\n        this.pos3 = event.changedTouches[0].clientX;\r\n        this.swipeId.style.left = (this.swipeId.offsetLeft - this.pos1) + 'px';\r\n      }\r\n      this.map.ol.render();\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Deactivate a listener of a mouse-action\r\n   */\r\n  closeDragMouseElement() {\r\n    document.onmouseup = null;\r\n    document.onmousemove = null;\r\n    this.inDragAction = false;\r\n  }\r\n\r\n  /**\r\n   * Deactivate a listener of a touch-action\r\n   */\r\n  closeDragTouchElement() {\r\n    document.ontouchend = null;\r\n    document.ontouchmove = null;\r\n    document.getElementById('arrows').style.visibility = 'visible';\r\n    this.inDragAction = false;\r\n  }\r\n\r\n  /**\r\n   * Cut the image of a layer by the position of swiped-element\r\n   */\r\n  prerender(event) {\r\n      const ctx = event.context;\r\n      const mapSize = this.map.ol.getSize();\r\n      const width = this.swipeId.offsetLeft ;\r\n      const tl = getRenderPixel(event, [width, 0]);\r\n      const tr = getRenderPixel(event, [0, 0]);\r\n      const bl = getRenderPixel(event, [width, mapSize[1]]);\r\n      const br = getRenderPixel(event, [0, mapSize[1]]);\r\n      ctx.save();\r\n      ctx.beginPath();\r\n      ctx.moveTo(tl[0], tl[1]);\r\n      ctx.lineTo(bl[0], bl[1]);\r\n      ctx.lineTo(br[0], br[1]);\r\n      ctx.lineTo(tr[0], tr[1]);\r\n      ctx.closePath();\r\n      ctx.clip();\r\n  }\r\n\r\n  /**\r\n   * Save a current state of the context\r\n   */\r\n  postrender(event){\r\n    event.context.restore();\r\n    event.context.save();\r\n  }\r\n\r\n  /**\r\n   * Zoom on div\r\n   */\r\n     private letZoom() {\r\n      document.getElementById('igo-layer-swipe').addEventListener('wheel', event => {\r\n        event.deltaY > 0 ? this.map.viewController.zoomOut() : this.map.viewController.zoomIn();\r\n      }, true);\r\n    }\r\n}\r\n","<div class=\"igo-swipe-control-container\"  id=\"igo-layer-swipe\"\r\n  (mousedown)=\"dragDown($event)\"\r\n  (mouseup)=\"closeDragMouseElement()\"\r\n  (touchstart)=\"dragDown($event)\"\r\n  (touchend)=\"closeDragTouchElement()\">\r\n  <div class=\"igo-swipe-control-line\" ></div>\r\n  \r\n  <div class=\"igo-swipe-control-arrows\" id=\"arrows\">\r\n    <div class=\"igo-arrow-left\"></div>\r\n    <div class=\"igo-arrow-right\"></div>\r\n  </div>\r\n</div>\r\n"]}