@igo2/geo 1.15.4 → 16.0.0-rc.1

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvamVjdGlvbi5pbnRlcmZhY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvbWFwL3NoYXJlZC9wcm9qZWN0aW9uLmludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgUHJvamVjdGlvbiB7XG4gIGFsaWFzPzogc3RyaW5nO1xuICBjb2RlOiBzdHJpbmc7XG4gIGRlZjogc3RyaW5nO1xuICBleHRlbnQ6IFtudW1iZXIsIG51bWJlciwgbnVtYmVyLCBudW1iZXJdO1xufVxuZXhwb3J0IGludGVyZmFjZSBJbnB1dFByb2plY3Rpb25zIHtcbiAgdHJhbnNsYXRlS2V5Pzogc3RyaW5nO1xuICB0cmFuc2xhdGVkVmFsdWU/OiBzdHJpbmc7XG4gIGFsaWFzOiBzdHJpbmc7XG4gIGNvZGU6IHN0cmluZztcbiAgem9uZTogc3RyaW5nO1xufVxuZXhwb3J0IGludGVyZmFjZSBQcm9qZWN0aW9uc0xpbWl0YXRpb25zT3B0aW9ucyB7XG4gIHByb2pGcm9tQ29uZmlnPzogYm9vbGVhbjtcbiAgbmFkODM/OiBib29sZWFuO1xuICB3Z3M4ND86IGJvb2xlYW47XG4gIHdlYk1lcmNhdG9yPzogYm9vbGVhbjtcbiAgdXRtPzogYm9vbGVhbjtcbiAgbXRtPzogYm9vbGVhbjtcbiAgdXRtWm9uZT86IHtcbiAgICBtaW5ab25lPzogbnVtYmVyO1xuICAgIG1heFpvbmU/OiBudW1iZXI7XG4gIH07XG4gIG10bVpvbmU/OiB7XG4gICAgbWluWm9uZT86IG51bWJlcjtcbiAgICBtYXhab25lPzogbnVtYmVyO1xuICB9O1xufVxuIl19

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

@@ -0,0 +1,67 @@
+import { Injectable } from '@angular/core';
+import proj4 from 'proj4';
+import * as olproj from 'ol/proj';
+import * as olproj4 from 'ol/proj/proj4';
+import { ConfigService } from '@igo2/core';
+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 {
+    config;
+    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);
+        }
+    }
+    static ɵfac = function ProjectionService_Factory(t) { return new (t || ProjectionService)(i0.ɵɵinject(i1.ConfigService)); };
+    static ɵ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/esm2022/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/esm2022/lib/map/swipe-control/index.mjs

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

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

@@ -0,0 +1,219 @@
+import { Component, Input } from '@angular/core';
+import { IgoMap } from '../shared/map';
+import { getRenderPixel } from 'ol/render';
+import * as i0 from "@angular/core";
+/**
+ * Tool to swipe the layers
+ */
+export class SwipeControlComponent {
+    /**
+     * Get an active map
+     */
+    map;
+    /**
+     * The list of layers for swipe
+     */
+    layers;
+    /**
+     * Final position of the swiped element
+     */
+    pos1;
+    /**
+     * Intermediate position of the swiped element
+     */
+    pos3;
+    /**
+     * State of draggable action
+     */
+    inDragAction = false;
+    /**
+     * Listener of toggle from advanced-map-tool
+     */
+    swipeEnabled$$;
+    /**
+     * Binder of prerender on the same element
+     */
+    boundPrerender = this.prerender.bind(this);
+    constructor() { }
+    /**
+     * 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() {
+        if (this.swipeId) {
+            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() {
+        if (this.swipeId) {
+            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);
+    }
+    static ɵfac = function SwipeControlComponent_Factory(t) { return new (t || SwipeControlComponent)(); };
+    static ɵ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:grab;z-index:1;transform:translate(-40px)}.igo-swipe-control-container[_ngcontent-%COMP%]:active{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\n  class=\"igo-swipe-control-container\"\n  id=\"igo-layer-swipe\"\n  (mousedown)=\"dragDown($event)\"\n  (mouseup)=\"closeDragMouseElement()\"\n  (touchstart)=\"dragDown($event)\"\n  (touchend)=\"closeDragTouchElement()\"\n>\n  <div class=\"igo-swipe-control-line\"></div>\n\n  <div class=\"igo-swipe-control-arrows\" id=\"arrows\">\n    <div class=\"igo-arrow-left\"></div>\n    <div class=\"igo-arrow-right\"></div>\n  </div>\n</div>\n", styles: [".igo-swipe-control-container{position:absolute;width:80px;height:100%;top:0%;left:50%;cursor:grab;z-index:1;transform:translate(-40px)}.igo-swipe-control-container:active{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';\nimport { Layer } from '../../layer/shared';\nimport { IgoMap } from '../shared/map';\nimport { getRenderPixel } from 'ol/render';\nimport { Subscription } from 'rxjs';\n\n/**\n * Tool to swipe the layers\n */\n@Component({\n  selector: 'igo-swipe-control',\n  templateUrl: './swipe-control.component.html',\n  styleUrls: ['./swipe-control.component.scss']\n})\nexport class SwipeControlComponent implements AfterViewInit, OnDestroy {\n  /**\n   * Get an active map\n   */\n  @Input() map: IgoMap;\n\n  /**\n   * The list of layers for swipe\n   */\n  private layers: Layer[];\n\n  /**\n   * Final position of the swiped element\n   */\n  private pos1: number;\n\n  /**\n   * Intermediate position of the swiped element\n   */\n  private pos3: number;\n\n  /**\n   * State of draggable action\n   */\n  private inDragAction: boolean = false;\n\n  /**\n   * Listener of toggle from advanced-map-tool\n   */\n  private swipeEnabled$$: Subscription;\n\n  /**\n   * Binder of prerender on the same element\n   */\n  private boundPrerender = this.prerender.bind(this);\n\n  constructor() {}\n\n  /**\n   * Get the list of layers for swipe and activate of deactivate the swipe\n   * @internal\n   */\n  ngAfterViewInit(): void {\n    this.getListOfLayers();\n    this.swipeEnabled$$ = this.map.swipeEnabled$.subscribe((value) => {\n      value ? this.displaySwipe() : this.displaySwipeOff();\n    });\n    this.letZoom();\n  }\n\n  /**\n   * Clear the overlay layer and any interaction added by this component.\n   * @internal\n   */\n  ngOnDestroy(): void {\n    this.swipeEnabled$$.unsubscribe();\n    this.map.swipeEnabled$.unsubscribe();\n    this.displaySwipeOff();\n  }\n\n  /**\n   * Display a swipe-element and render the layers\n   */\n  displaySwipe() {\n    if (this.swipeId) {\n      this.swipeId.style.visibility = 'visible';\n    }\n    this.layers.map((layer) => layer.ol.on('prerender', this.boundPrerender));\n    this.layers.map((layer) => layer.ol.on('postrender', this.postrender));\n    this.map.ol.render();\n  }\n\n  /**\n   * Clear a swipe-element and render the layers on the initial state\n   */\n  displaySwipeOff() {\n    if (this.swipeId) {\n      this.swipeId.style.visibility = 'hidden';\n    }\n    this.layers.map((layer) => layer.ol.un('prerender', this.boundPrerender));\n    this.layers.map((layer) => layer.ol.un('postrender', this.postrender));\n    this.map.ol.render();\n    this.layers = [];\n  }\n\n  /**\n   * Getter of element\n   */\n  get swipeId() {\n    return document.getElementById('igo-layer-swipe');\n  }\n\n  /**\n   * Get the list of layers for swipe\n   */\n  getListOfLayers() {\n    this.map.selectedFeatures$.subscribe((layers) => {\n      this.layers = [];\n      if (layers !== null) {\n        for (const layer of layers) {\n          if (!this.layers.includes(layer)) {\n            this.layers.push(layer);\n          }\n        }\n      }\n    });\n  }\n\n  /**\n   * Get a position of click or touch\n   */\n  dragDown(event) {\n    this.inDragAction = true;\n    event.preventDefault();\n    if (event.type === 'mousedown') {\n      this.pos3 = event.clientX;\n      this.mouseSwipe();\n      document.onmouseup = this.closeDragMouseElement;\n    } else if (event.type === 'touchstart') {\n      document.getElementById('arrows').style.visibility = 'hidden';\n      this.pos3 = event.touches[0].clientX;\n      this.touchSwipe();\n      document.ontouchend = this.closeDragTouchElement;\n    }\n  }\n\n  /**\n   * Moving a line with a mouse\n   */\n  mouseSwipe() {\n    document.addEventListener('mousemove', (event) => {\n      if (this.inDragAction) {\n        event.preventDefault();\n        this.pos1 = this.pos3 - event.clientX;\n        this.pos3 = event.clientX;\n        this.swipeId.style.left = this.swipeId.offsetLeft - this.pos1 + 'px';\n      }\n      this.map.ol.render();\n    });\n  }\n\n  /**\n   * Moving a line with a touch\n   */\n  touchSwipe() {\n    document.addEventListener('touchmove', (event) => {\n      if (this.inDragAction) {\n        event.preventDefault();\n        document.getElementById('arrows').style.visibility = 'hidden';\n        this.pos1 = this.pos3 - event.changedTouches[0].clientX;\n        this.pos3 = event.changedTouches[0].clientX;\n        this.swipeId.style.left = this.swipeId.offsetLeft - this.pos1 + 'px';\n      }\n      this.map.ol.render();\n    });\n  }\n\n  /**\n   * Deactivate a listener of a mouse-action\n   */\n  closeDragMouseElement() {\n    document.onmouseup = null;\n    document.onmousemove = null;\n    this.inDragAction = false;\n  }\n\n  /**\n   * Deactivate a listener of a touch-action\n   */\n  closeDragTouchElement() {\n    document.ontouchend = null;\n    document.ontouchmove = null;\n    document.getElementById('arrows').style.visibility = 'visible';\n    this.inDragAction = false;\n  }\n\n  /**\n   * Cut the image of a layer by the position of swiped-element\n   */\n  prerender(event) {\n    const ctx = event.context;\n    const mapSize = this.map.ol.getSize();\n    const width = this.swipeId.offsetLeft;\n    const tl = getRenderPixel(event, [width, 0]);\n    const tr = getRenderPixel(event, [0, 0]);\n    const bl = getRenderPixel(event, [width, mapSize[1]]);\n    const br = getRenderPixel(event, [0, mapSize[1]]);\n    ctx.save();\n    ctx.beginPath();\n    ctx.moveTo(tl[0], tl[1]);\n    ctx.lineTo(bl[0], bl[1]);\n    ctx.lineTo(br[0], br[1]);\n    ctx.lineTo(tr[0], tr[1]);\n    ctx.closePath();\n    ctx.clip();\n  }\n\n  /**\n   * Save a current state of the context\n   */\n  postrender(event) {\n    event.context.restore();\n    event.context.save();\n  }\n\n  /**\n   * Zoom on div\n   */\n  private letZoom() {\n    document.getElementById('igo-layer-swipe').addEventListener(\n      'wheel',\n      (event) => {\n        event.deltaY > 0\n          ? this.map.viewController.zoomOut()\n          : this.map.viewController.zoomIn();\n      },\n      true\n    );\n  }\n}\n","<div\n  class=\"igo-swipe-control-container\"\n  id=\"igo-layer-swipe\"\n  (mousedown)=\"dragDown($event)\"\n  (mouseup)=\"closeDragMouseElement()\"\n  (touchstart)=\"dragDown($event)\"\n  (touchend)=\"closeDragTouchElement()\"\n>\n  <div class=\"igo-swipe-control-line\"></div>\n\n  <div class=\"igo-swipe-control-arrows\" id=\"arrows\">\n    <div class=\"igo-arrow-left\"></div>\n    <div class=\"igo-arrow-right\"></div>\n  </div>\n</div>\n"]}

package/esm2022/lib/map/utils/layer-watcher.mjs

@@ -0,0 +1,78 @@
+import { BehaviorSubject } from 'rxjs';
+import { distinctUntilChanged } from 'rxjs/operators';
+import { Watcher, SubjectStatus } from '@igo2/utils';
+import { LinkedProperties } from '../../layer/shared/layers';
+export class LayerWatcher extends Watcher {
+    propertyChange$ = new BehaviorSubject(undefined);
+    loaded = 0;
+    loading = 0;
+    layers = [];
+    subscriptions = [];
+    constructor() {
+        super();
+    }
+    watch() { }
+    unwatch() {
+        this.layers.forEach((layer) => this.unwatchLayer(layer), this);
+    }
+    setPropertyChange(change, layer) {
+        if (![
+            LinkedProperties.TIMEFILTER,
+            LinkedProperties.OGCFILTERS,
+            LinkedProperties.VISIBLE,
+            LinkedProperties.OPACITY,
+            LinkedProperties.MINRESOLUTION,
+            LinkedProperties.MAXRESOLUTION
+        ].includes(change.key)) {
+            return;
+        }
+        this.propertyChange$.next({ event: change, layer });
+    }
+    watchLayer(layer) {
+        if (layer.status$ === undefined) {
+            return;
+        }
+        layer.ol.on('propertychange', (evt) => this.setPropertyChange(evt, layer));
+        layer.dataSource.ol.on('propertychange', (evt) => this.setPropertyChange(evt, layer));
+        this.layers.push(layer);
+        const layer$$ = layer.status$
+            .pipe(distinctUntilChanged())
+            .subscribe((status) => {
+            if (status === SubjectStatus.Error) {
+                this.loading = 0;
+                this.loaded = -1;
+            }
+            if (status === SubjectStatus.Working) {
+                this.loading += 1;
+            }
+            else if (status === SubjectStatus.Done) {
+                this.loaded += 1;
+            }
+            if (this.loaded >= this.loading) {
+                this.loading = this.loaded = 0;
+                this.status = SubjectStatus.Done;
+            }
+            else if (this.loading > 0) {
+                this.status = SubjectStatus.Working;
+            }
+        });
+        this.subscriptions.push(layer$$);
+    }
+    unwatchLayer(layer) {
+        layer.ol.un('propertychange', (evt) => this.setPropertyChange(evt, layer));
+        layer.dataSource.ol.un('propertychange', (evt) => this.setPropertyChange(evt, layer));
+        layer.status$.next(SubjectStatus.Done);
+        const index = this.layers.indexOf(layer);
+        if (index >= 0) {
+            const status = layer.watcher.status;
+            if ([SubjectStatus.Working, SubjectStatus.Waiting].indexOf(status) !== -1) {
+                this.loaded += 1;
+            }
+            this.subscriptions[index].unsubscribe();
+            this.subscriptions.splice(index, 1);
+            this.layers.splice(index, 1);
+            layer.watcher.unwatch();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/map/wake-lock-button/index.mjs

@@ -0,0 +1,2 @@
+export * from './wake-lock-button.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9tYXAvd2FrZS1sb2NrLWJ1dHRvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDhCQUE4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi93YWtlLWxvY2stYnV0dG9uLmNvbXBvbmVudCc7XG4iXX0=

package/esm2022/lib/map/wake-lock-button/wake-lock-button.component.mjs

@@ -0,0 +1,106 @@
+import { Component, Input } from '@angular/core';
+import { StorageService } from '@igo2/core';
+import { BehaviorSubject } from 'rxjs';
+import NoSleep from 'nosleep.js';
+import { userAgent } from '@igo2/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core";
+import * as i2 from "@angular/material/icon";
+import * as i3 from "@angular/material/button";
+import * as i4 from "@angular/material/tooltip";
+import * as i5 from "@angular/common";
+import * as i6 from "@ngx-translate/core";
+/**
+ * Prevent display sleep and enable wake lock in all Android and iOS web browsers.
+ * On iOS, the Wake Lock API is not supported
+ * https://developer.mozilla.org/en-US/docs/Web/API/Screen_Wake_Lock_API
+ * On not supported browser, a fake video is used to keep the screen open.
+ *
+ * TODO: When the API will be supported by every browser, We should remove the NoSleep.js dependency
+ * and replace it by a WakeLock API implementation.
+ */
+export class WakeLockButtonComponent {
+    storageService;
+    color = 'primary';
+    get enabled() {
+        return this.storageService.get('wakeLockEnabled');
+    }
+    set enabled(value) {
+        this.storageService.set('wakeLockEnabled', value);
+    }
+    noSleep;
+    icon$ = new BehaviorSubject('sleep');
+    visible = false;
+    constructor(storageService) {
+        this.storageService = storageService;
+        this.noSleep = new NoSleep();
+        const nonWakeLockApiBrowser = userAgent.satisfies({
+            ie: '>0',
+            edge: '<84',
+            chrome: '<84',
+            firefox: '>0',
+            opera: '<70',
+            safari: '>0'
+        });
+        if (nonWakeLockApiBrowser) {
+            this.disableWakeLock();
+            this.enabled = false;
+            window.addEventListener('blur', () => {
+                this.disableWakeLock();
+                this.enabled = false;
+            });
+        }
+        this.enabled ? this.enableWakeLock() : this.disableWakeLock();
+    }
+    /**
+     * Prevent display sleep and enable wake lock in all Android and iOS web browsers.
+     * On iOS, the Wake Lock API is not supported
+     * https://developer.mozilla.org/en-US/docs/Web/API/Screen_Wake_Lock_API
+     * On not supported browser, a fake video is used to keep the screen open.
+     */
+    enableWakeLock() {
+        this.noSleep.enable();
+        this.enabled = true;
+        this.icon$.next('sleep-off');
+    }
+    /**
+     * Let display sleep
+     */
+    disableWakeLock() {
+        this.noSleep.disable();
+        this.enabled = false;
+        this.icon$.next('sleep');
+    }
+    toggleWakeLock() {
+        if (this.enabled) {
+            this.disableWakeLock();
+        }
+        else {
+            this.enableWakeLock();
+        }
+    }
+    static ɵfac = function WakeLockButtonComponent_Factory(t) { return new (t || WakeLockButtonComponent)(i0.ɵɵdirectiveInject(i1.StorageService)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: WakeLockButtonComponent, selectors: [["igo-wake-lock-button"]], inputs: { color: "color", enabled: "enabled" }, decls: 6, vars: 9, consts: [[1, "igo-wake-lock-button-container"], ["mat-icon-button", "", "matTooltipPosition", "left", 3, "color", "matTooltip", "click"], [3, "svgIcon"]], template: function WakeLockButtonComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 0)(1, "button", 1);
+            i0.ɵɵlistener("click", function WakeLockButtonComponent_Template_button_click_1_listener() { return ctx.toggleWakeLock(); });
+            i0.ɵɵpipe(2, "translate");
+            i0.ɵɵpipe(3, "translate");
+            i0.ɵɵelement(4, "mat-icon", 2);
+            i0.ɵɵpipe(5, "async");
+            i0.ɵɵelementEnd()();
+        } if (rf & 2) {
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("color", ctx.color)("matTooltip", ctx.enabled ? i0.ɵɵpipeBind1(2, 3, "igo.geo.mapButtons.preventScreenLock") : i0.ɵɵpipeBind1(3, 5, "igo.geo.mapButtons.letScreenLock"));
+            i0.ɵɵadvance(3);
+            i0.ɵɵpropertyInterpolate("svgIcon", i0.ɵɵpipeBind1(5, 7, ctx.icon$));
+        } }, dependencies: [i2.MatIcon, i3.MatIconButton, i4.MatTooltip, i5.AsyncPipe, i6.TranslatePipe], styles: ["[_nghost-%COMP%]   button[_ngcontent-%COMP%]{border-radius:0!important}[_nghost-%COMP%]   button[_ngcontent-%COMP%]   .mat-ripple[_ngcontent-%COMP%], [_nghost-%COMP%]   button[_ngcontent-%COMP%]   .mdc-icon-button__ripple[_ngcontent-%COMP%]{border-radius:0!important}[_nghost-%COMP%]   .igo-wake-lock-button-container[_ngcontent-%COMP%]{width:40px;background-color:#fff}[_nghost-%COMP%]   .igo-wake-lock-button-container[_ngcontent-%COMP%]:hover{background-color:#efefef}"] });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WakeLockButtonComponent, [{
+        type: Component,
+        args: [{ selector: 'igo-wake-lock-button', template: "<div class=\"igo-wake-lock-button-container\">\n  <button\n    [color]=\"color\"\n    mat-icon-button\n    [matTooltip]=\"\n      enabled\n        ? ('igo.geo.mapButtons.preventScreenLock' | translate)\n        : ('igo.geo.mapButtons.letScreenLock' | translate)\n    \"\n    matTooltipPosition=\"left\"\n    (click)=\"toggleWakeLock()\"\n  >\n    <mat-icon svgIcon=\"{{ icon$ | async }}\"></mat-icon>\n  </button>\n</div>\n", styles: [":host button{border-radius:0!important}:host button .mat-ripple,:host button .mdc-icon-button__ripple{border-radius:0!important}:host .igo-wake-lock-button-container{width:40px;background-color:#fff}:host .igo-wake-lock-button-container:hover{background-color:#efefef}\n"] }]
+    }], function () { return [{ type: i1.StorageService }]; }, { color: [{
+            type: Input
+        }], enabled: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/map/zoom-button/index.mjs

@@ -0,0 +1,2 @@
+export * from './zoom-button.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9tYXAvem9vbS1idXR0b24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vem9vbS1idXR0b24uY29tcG9uZW50JztcbiJdfQ==