@igo2/geo 18.0.1-next.2 → 18.0.2

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

@@ -0,0 +1,114 @@
+import { Directive } from '@angular/core';
+import { MessageService } from '@igo2/core/message';
+import { NetworkService } from '@igo2/core/network';
+import { SubjectStatus } from '@igo2/utils';
+import { combineLatest, filter } from 'rxjs';
+import { isLayerGroup } from '../../layer';
+import { MapBrowserComponent } from '../map-browser/map-browser.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../map-browser/map-browser.component";
+import * as i2 from "@igo2/core/network";
+import * as i3 from "@igo2/core/message";
+export class MapOfflineDirective {
+    networkService;
+    messageService;
+    component;
+    get map() {
+        return this.component.map;
+    }
+    previousMessageId;
+    constructor(component, networkService, messageService) {
+        this.networkService = networkService;
+        this.messageService = messageService;
+        this.component = component;
+    }
+    ngAfterViewInit() {
+        const initialOnline = window.navigator.onLine;
+        this.map.forcedOffline$.subscribe((forcedOffline) => {
+            const online = window.navigator.onLine;
+            // prevent first online message if no state change.
+            if (initialOnline && initialOnline === online && !forcedOffline) {
+                return;
+            }
+            if (this.previousMessageId) {
+                this.messageService.remove(this.previousMessageId);
+            }
+            if (!forcedOffline && online) {
+                const messageObj = this.messageService.info('igo.geo.network.online.message', 'igo.geo.network.online.title');
+                this.previousMessageId = messageObj.toastId;
+            }
+            else if (forcedOffline) {
+                const messageObj = this.messageService.info('igo.geo.network.offline.message', 'igo.geo.network.offline.title');
+                this.previousMessageId = messageObj.toastId;
+            }
+        });
+        combineLatest([
+            this.networkService.currentState(),
+            this.map.forcedOffline$,
+            this.map.status$.pipe(filter((status) => status === SubjectStatus.Done))
+        ]).subscribe((bunch) => {
+            const online = bunch[0].connection;
+            const forcedOffline = bunch[1];
+            this.handleLayersOnlineState(online, forcedOffline, this.map.layerController.all);
+        });
+    }
+    handleNonOfflinableLayerResolution(online, forcedOffline, layer) {
+        if (!online || forcedOffline) {
+            layer.maxResolution = 0;
+        }
+        else if (online || !forcedOffline) {
+            layer.maxResolution = layer.options.maxResolution || Infinity;
+        }
+    }
+    handleLayersOnlineState(online, forcedOffline, layers) {
+        layers.forEach((layer) => {
+            if (isLayerGroup(layer)) {
+                return;
+            }
+            let offlinableByUrlSourceOptions;
+            if (layer.isIgoInternalLayer) {
+                return;
+            }
+            // detect if layer/source are offlinable by url/pathOffline properties
+            if (layer.options.sourceOptions?.pathOffline) {
+                offlinableByUrlSourceOptions = layer.options.sourceOptions;
+            }
+            if (offlinableByUrlSourceOptions) {
+                const type = offlinableByUrlSourceOptions.type;
+                if (type === 'mvt') {
+                    layer.ol.getSource().refresh();
+                }
+                if (!online || forcedOffline) {
+                    if (['vector', 'cluster'].includes(type)) {
+                        return;
+                    }
+                    layer.ol.getSource().setUrl(offlinableByUrlSourceOptions.pathOffline);
+                }
+                else if (!online || !forcedOffline) {
+                    if (['vector', 'cluster'].includes(type)) {
+                        return;
+                    }
+                    layer.ol.getSource().setUrl(offlinableByUrlSourceOptions.url);
+                }
+                else {
+                    this.handleNonOfflinableLayerResolution(online, forcedOffline, layer);
+                }
+            }
+            else {
+                // FOR ALL NON OFFLINABLE SOURCE (i.e. EXCEPT PREVIOUS);
+                this.handleNonOfflinableLayerResolution(online, forcedOffline, layer);
+                return;
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MapOfflineDirective, deps: [{ token: i1.MapBrowserComponent }, { token: i2.NetworkService }, { token: i3.MessageService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: MapOfflineDirective, isStandalone: true, selector: "[igoMapOffline]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MapOfflineDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[igoMapOffline]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.MapBrowserComponent }, { type: i2.NetworkService }, { type: i3.MessageService }] });
+//# 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 { AfterViewInit, Directive } from '@angular/core';\n\nimport { MessageService } from '@igo2/core/message';\nimport { NetworkService } from '@igo2/core/network';\nimport { SubjectStatus } from '@igo2/utils';\n\nimport { combineLatest, filter } from 'rxjs';\n\nimport { DataSourceOptions } from '../../datasource/shared/datasources/datasource.interface';\nimport { AnyLayer, isLayerGroup } from '../../layer';\nimport { MapBrowserComponent } from '../map-browser/map-browser.component';\nimport { IgoMap } from './map';\n\ninterface OfflinableSourceOptions extends DataSourceOptions {\n  pathOffline?: string;\n}\n\n@Directive({\n  selector: '[igoMapOffline]',\n  standalone: true\n})\nexport class MapOfflineDirective implements AfterViewInit {\n  private component: MapBrowserComponent;\n\n  get map(): IgoMap {\n    return this.component.map;\n  }\n\n  private previousMessageId;\n\n  constructor(\n    component: MapBrowserComponent,\n    private networkService: NetworkService,\n    private messageService: MessageService\n  ) {\n    this.component = component;\n  }\n\n  ngAfterViewInit() {\n    const initialOnline = window.navigator.onLine;\n    this.map.forcedOffline$.subscribe((forcedOffline: boolean) => {\n      const online = window.navigator.onLine;\n      // prevent first online message if no state change.\n      if (initialOnline && initialOnline === online && !forcedOffline) {\n        return;\n      }\n      if (this.previousMessageId) {\n        this.messageService.remove(this.previousMessageId);\n      }\n      if (!forcedOffline && online) {\n        const messageObj = this.messageService.info(\n          'igo.geo.network.online.message',\n          'igo.geo.network.online.title'\n        );\n        this.previousMessageId = messageObj.toastId;\n      } else if (forcedOffline) {\n        const messageObj = this.messageService.info(\n          'igo.geo.network.offline.message',\n          'igo.geo.network.offline.title'\n        );\n        this.previousMessageId = messageObj.toastId;\n      }\n    });\n\n    combineLatest([\n      this.networkService.currentState(),\n      this.map.forcedOffline$,\n      this.map.status$.pipe(filter((status) => status === SubjectStatus.Done))\n    ]).subscribe((bunch) => {\n      const online = bunch[0].connection;\n      const forcedOffline = bunch[1];\n      this.handleLayersOnlineState(\n        online,\n        forcedOffline,\n        this.map.layerController.all\n      );\n    });\n  }\n\n  private handleNonOfflinableLayerResolution(\n    online: boolean,\n    forcedOffline: boolean,\n    layer: AnyLayer\n  ) {\n    if (!online || forcedOffline) {\n      layer.maxResolution = 0;\n    } else if (online || !forcedOffline) {\n      layer.maxResolution = layer.options.maxResolution || Infinity;\n    }\n  }\n\n  private handleLayersOnlineState(\n    online: boolean,\n    forcedOffline: boolean,\n    layers: AnyLayer[]\n  ) {\n    layers.forEach((layer) => {\n      if (isLayerGroup(layer)) {\n        return;\n      }\n      let offlinableByUrlSourceOptions;\n      if (layer.isIgoInternalLayer) {\n        return;\n      }\n      // detect if layer/source are offlinable by url/pathOffline properties\n      if (\n        (layer.options.sourceOptions as OfflinableSourceOptions)?.pathOffline\n      ) {\n        offlinableByUrlSourceOptions = layer.options.sourceOptions;\n      }\n      if (offlinableByUrlSourceOptions) {\n        const type = offlinableByUrlSourceOptions.type;\n        if (type === 'mvt') {\n          layer.ol.getSource().refresh();\n        }\n        if (!online || forcedOffline) {\n          if (['vector', 'cluster'].includes(type)) {\n            return;\n          }\n          (layer.ol.getSource() as any).setUrl(\n            offlinableByUrlSourceOptions.pathOffline\n          );\n        } else if (!online || !forcedOffline) {\n          if (['vector', 'cluster'].includes(type)) {\n            return;\n          }\n          (layer.ol.getSource() as any).setUrl(\n            offlinableByUrlSourceOptions.url\n          );\n        } else {\n          this.handleNonOfflinableLayerResolution(online, forcedOffline, layer);\n        }\n      } else {\n        // FOR ALL NON OFFLINABLE SOURCE (i.e. EXCEPT PREVIOUS);\n        this.handleNonOfflinableLayerResolution(online, forcedOffline, layer);\n        return;\n      }\n    });\n  }\n}\n"]}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvamVjdGlvbi5pbnRlcmZhY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvbWFwL3NoYXJlZC9wcm9qZWN0aW9uLmludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgUHJvamVjdGlvbiB7XG4gIGFsaWFzPzogc3RyaW5nO1xuICBjb2RlOiBzdHJpbmc7XG4gIGRlZjogc3RyaW5nO1xuICBleHRlbnQ6IFtudW1iZXIsIG51bWJlciwgbnVtYmVyLCBudW1iZXJdO1xufVxuZXhwb3J0IGludGVyZmFjZSBJbnB1dFByb2plY3Rpb25zIGV4dGVuZHMgUHJvamVjdGlvbiB7XG4gIHRyYW5zbGF0ZUtleT86IHN0cmluZztcbiAgdHJhbnNsYXRlZFZhbHVlPzogc3RyaW5nO1xuICB6b25lOiBzdHJpbmc7XG59XG5leHBvcnQgaW50ZXJmYWNlIFByb2plY3Rpb25zTGltaXRhdGlvbnNPcHRpb25zIHtcbiAgcHJvakZyb21Db25maWc/OiBib29sZWFuO1xuICBuYWQ4Mz86IGJvb2xlYW47XG4gIHdnczg0PzogYm9vbGVhbjtcbiAgd2ViTWVyY2F0b3I/OiBib29sZWFuO1xuICB1dG0/OiBib29sZWFuO1xuICBtdG0/OiBib29sZWFuO1xuICB1dG1ab25lPzoge1xuICAgIG1pblpvbmU/OiBudW1iZXI7XG4gICAgbWF4Wm9uZT86IG51bWJlcjtcbiAgfTtcbiAgbXRtWm9uZT86IHtcbiAgICBtaW5ab25lPzogbnVtYmVyO1xuICAgIG1heFpvbmU/OiBudW1iZXI7XG4gIH07XG59XG4iXX0=

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

@@ -0,0 +1,67 @@
+import { Injectable } from '@angular/core';
+import { ConfigService } from '@igo2/core/config';
+import * as olproj from 'ol/proj';
+import * as olproj4 from 'ol/proj/proj4';
+import proj4 from 'proj4';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core/config";
+/**
+ * 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 = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProjectionService, deps: [{ token: i1.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProjectionService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProjectionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.ConfigService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,122 @@
+import { from } from 'rxjs';
+/**
+ * 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 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;
+}
+/**
+ * Method allowing to read the file and try to detect projection/Coord system
+ * Only geojson/json/gml could be detected at this moment.
+ * @param options A file and an optional number of line to read the EPSG Code. Used only for GML files
+ * @returns Observable string, epsgNotDefined if the EPSG is not detected or a EPSG string ex: EPSG:3857
+ */
+export function detectFileEPSG(options) {
+    const file = options.file;
+    const nbLines = options.nbLines ?? 500;
+    const reader = new FileReader();
+    return from(new Promise((resolve) => {
+        if (!file.name.toLowerCase().endsWith('.geojson') &&
+            !file.name.toLowerCase().endsWith('.json') &&
+            !file.name.toLowerCase().endsWith('.gml')) {
+            resolve('epsgNotDefined');
+            return;
+        }
+        reader.onload = () => {
+            if (file.name.toLowerCase().endsWith('.geojson') ||
+                file.name.toLowerCase().endsWith('.json')) {
+                const geojson = JSON.parse(reader.result);
+                if (geojson.crs?.properties?.name) {
+                    const epsg = geojson.crs.properties.name.match(/EPSG:{1,2}\d{0,6}/gm);
+                    if (epsg !== null && epsg.length) {
+                        resolve(epsg[0].replace(/::/g, ':'));
+                        return;
+                    }
+                    else {
+                        resolve('epsgNotDefined');
+                        return;
+                    }
+                }
+                else {
+                    resolve('epsgNotDefined');
+                    return;
+                }
+            }
+            else if (file.name.toLowerCase().endsWith('.gml')) {
+                const text = reader.result;
+                const lines = text.split('\n');
+                for (let line = 0; line <= nbLines; line++) {
+                    const epsg = lines[line].match(/EPSG:\d{0,6}/gm);
+                    if (epsg !== null && epsg.length) {
+                        resolve(epsg[0]);
+                        break;
+                    }
+                    else {
+                        resolve(undefined);
+                    }
+                }
+            }
+            else {
+                resolve('epsgNotDefined');
+            }
+        };
+        reader.readAsText(file, 'UTF-8');
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"projection.utils.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/map/shared/projection.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, from } from 'rxjs';\n\nimport { ProjectionsLimitationsOptions } from './projection.interfaces';\n\n/**\n * Return a number of zone MTM for a longitude for province of Quebec only\n * @param lon number\n * @returns zone\n */\nexport function zoneMtm(lon: number): number {\n  let lonMin = -54;\n  const lonMax = -81;\n  if (lon < lonMax || lon > lonMin) {\n    return 0;\n  } else {\n    const deltaLon = 3;\n    let zone = 2;\n    while (Math.abs(lon - lonMin) > deltaLon) {\n      lonMin = lonMin - deltaLon;\n      zone++;\n    }\n    return zone;\n  }\n}\n/**\n * Return a number of zone UTM for a longitude\n * @param lon number\n * @returns zone\n */\nexport function zoneUtm(lon: number): number {\n  let lonMin = -180;\n  const deltaLon = 6;\n  let zone = 1;\n  while (Math.abs(lon - lonMin) > deltaLon) {\n    lonMin = lonMin + deltaLon;\n    zone++;\n  }\n  return zone;\n}\n\n/**\n * Compute the contraints of projections\n * @param projectionsLimitations: ProjectionsLimitationsOptions\n * @returns projectionsContraints: ProjectionsLimitationsOptions\n */\nexport function computeProjectionsConstraints(\n  projectionsLimitations: ProjectionsLimitationsOptions\n): ProjectionsLimitationsOptions {\n  const mtmZone = projectionsLimitations.mtmZone;\n  const utmZone = projectionsLimitations.utmZone;\n  const projectionsConstraints = {\n    projFromConfig:\n      projectionsLimitations.projFromConfig === false ? false : true,\n    nad83: projectionsLimitations.nad83 === false ? false : true,\n    wgs84: projectionsLimitations.wgs84 === false ? false : true,\n    webMercator: projectionsLimitations.webMercator === false ? false : true,\n    utm: projectionsLimitations.utm === false ? false : true,\n    mtm: projectionsLimitations.mtm === false ? false : true,\n    utmZone: {\n      minZone: utmZone && utmZone.minZone ? utmZone.minZone : 17,\n      maxZone: utmZone && utmZone.maxZone ? utmZone.maxZone : 21\n    },\n    mtmZone: {\n      minZone: mtmZone && mtmZone.minZone ? mtmZone.minZone : 2,\n      maxZone: mtmZone && mtmZone.maxZone ? mtmZone.maxZone : 10\n    }\n  };\n  return projectionsConstraints;\n}\n/**\n * Method allowing to read the file and try to detect projection/Coord system\n * Only geojson/json/gml could be detected at this moment.\n * @param options A file and an optional number of line to read the EPSG Code. Used only for GML files\n * @returns Observable string, epsgNotDefined if the EPSG is not detected or a EPSG string ex: EPSG:3857\n */\nexport function detectFileEPSG(options: {\n  file: File;\n  nbLines?: number;\n}): Observable<string> {\n  const file = options.file;\n  const nbLines = options.nbLines ?? 500;\n\n  const reader = new FileReader();\n  return from(\n    new Promise<string>((resolve) => {\n      if (\n        !file.name.toLowerCase().endsWith('.geojson') &&\n        !file.name.toLowerCase().endsWith('.json') &&\n        !file.name.toLowerCase().endsWith('.gml')\n      ) {\n        resolve('epsgNotDefined');\n        return;\n      }\n\n      reader.onload = () => {\n        if (\n          file.name.toLowerCase().endsWith('.geojson') ||\n          file.name.toLowerCase().endsWith('.json')\n        ) {\n          const geojson = JSON.parse(reader.result as string);\n          if (geojson.crs?.properties?.name) {\n            const epsg =\n              geojson.crs.properties.name.match(/EPSG:{1,2}\\d{0,6}/gm);\n            if (epsg !== null && epsg.length) {\n              resolve(epsg[0].replace(/::/g, ':'));\n              return;\n            } else {\n              resolve('epsgNotDefined');\n              return;\n            }\n          } else {\n            resolve('epsgNotDefined');\n            return;\n          }\n        } else if (file.name.toLowerCase().endsWith('.gml')) {\n          const text = reader.result as string;\n          const lines = (text as string).split('\\n');\n          for (let line = 0; line <= nbLines; line++) {\n            const epsg = lines[line].match(/EPSG:\\d{0,6}/gm);\n            if (epsg !== null && epsg.length) {\n              resolve(epsg[0]);\n              break;\n            } else {\n              resolve(undefined);\n            }\n          }\n        } else {\n          resolve('epsgNotDefined');\n        }\n      };\n      reader.readAsText(file, 'UTF-8');\n    })\n  );\n}\n"]}

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,211 @@
+import { Component, Input } from '@angular/core';
+import { getRenderPixel } from 'ol/render';
+import { IgoMap } from '../shared/map';
+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);
+    /**
+     * 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 = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SwipeControlComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: SwipeControlComponent, isStandalone: true, selector: "igo-swipe-control", inputs: { map: "map" }, ngImport: i0, 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"] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SwipeControlComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'igo-swipe-control', standalone: true, 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"] }]
+        }], propDecorators: { 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 { AfterViewInit, Component, Input, OnDestroy } from '@angular/core';\n\nimport { getRenderPixel } from 'ol/render';\n\nimport { Subscription } from 'rxjs';\n\nimport { Layer } from '../../layer';\nimport { IgoMap } from '../shared/map';\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  standalone: true\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 = 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  /**\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/index.mjs

@@ -0,0 +1,2 @@
+export * from './layer-watcher';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9tYXAvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGF5ZXItd2F0Y2hlcic7XG4iXX0=