@igo2/geo 18.0.1-next.2 → 18.0.2

package/esm2022/lib/offline/layerDB/layerDB.service.mjs

@@ -0,0 +1,83 @@
+import { Injectable, Optional } from '@angular/core';
+import { NgxIndexedDBService } from 'ngx-indexed-db';
+import { Subject, of } from 'rxjs';
+import { concatMap, first } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-indexed-db";
+export class LayerDBService {
+    ngxIndexedDBService;
+    dbName = 'layerData';
+    constructor(ngxIndexedDBService) {
+        this.ngxIndexedDBService = ngxIndexedDBService;
+    }
+    /**
+     * This method allow to update the stored layer into the indexeddb (layerData)
+     * @param layerDBData
+     * @returns
+     */
+    update(layerDBData) {
+        const subject = new Subject();
+        this.ngxIndexedDBService
+            ?.getByID(this.dbName, layerDBData.layerId)
+            .pipe(first(), concatMap((dbObject) => {
+            if (!dbObject) {
+                return this.ngxIndexedDBService?.add(this.dbName, layerDBData);
+            }
+            else {
+                return this.customUpdate(layerDBData);
+            }
+        }))
+            .subscribe((response) => {
+            subject.next(response);
+            subject.complete();
+        });
+        return subject;
+    }
+    customUpdate(layerDBData) {
+        const subject = new Subject();
+        const deleteRequest = this.ngxIndexedDBService?.deleteByKey(this.dbName, layerDBData.layerId);
+        deleteRequest
+            .pipe(concatMap((isDeleted) => isDeleted
+            ? this.ngxIndexedDBService?.add(this.dbName, layerDBData)
+            : of(undefined)))
+            .subscribe((object) => {
+            if (object) {
+                subject.next(object);
+            }
+            subject.complete();
+        });
+        return subject;
+    }
+    /**
+     * This method retrieve an idb layer definition
+     * @param layerId
+     * @returns
+     */
+    getByID(layerId) {
+        return this.ngxIndexedDBService?.getByID(this.dbName, layerId);
+    }
+    /**
+     * This method delete an idb layer definition
+     * @param layerId
+     * @returns
+     */
+    deleteByKey(layerId) {
+        return this.ngxIndexedDBService?.deleteByKey(this.dbName, layerId);
+    }
+    /**
+     * This method retrive all idb layer definition
+     * @param layerId
+     * @returns
+     */
+    getAll() {
+        return this.ngxIndexedDBService?.getAll(this.dbName);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LayerDBService, deps: [{ token: i1.NgxIndexedDBService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LayerDBService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LayerDBService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.NgxIndexedDBService, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/offline/offline.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2ZmbGluZS5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9vZmZsaW5lL29mZmxpbmUuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIElPZmZsaW5lT3B0aW9ucyB7XG4gIGVuYWJsZTogYm9vbGVhbjtcbn1cbiJdfQ==

package/esm2022/lib/offline/offline.provider.mjs

@@ -0,0 +1,50 @@
+import { makeEnvironmentProviders } from '@angular/core';
+import { provideIndexedDb } from 'ngx-indexed-db';
+import { ConfigFileToGeoDBService, GeoDBService } from './geoDB';
+import { LayerDBService } from './layerDB';
+import { GeoNetworkService } from './shared';
+const dbConfig = {
+    name: 'igo2DB',
+    version: 2,
+    objectStoresMeta: [
+        {
+            store: 'geoData',
+            storeConfig: { keyPath: 'url', autoIncrement: false },
+            storeSchema: [
+                { name: 'regionID', keypath: 'regionID', options: { unique: false } }
+            ]
+        },
+        {
+            store: 'layerData',
+            storeConfig: { keyPath: 'layerId', autoIncrement: false },
+            storeSchema: [
+                {
+                    name: 'layerOptions',
+                    keypath: 'layerOptions',
+                    options: { unique: false }
+                },
+                {
+                    name: 'sourceOptions',
+                    keypath: 'sourceOptions',
+                    options: { unique: false }
+                }
+            ]
+        }
+    ]
+};
+export function provideOffline(options) {
+    const dbConfigFormatted = {};
+    for (const config of [dbConfig]) {
+        Object.assign(dbConfigFormatted, { [config.name]: dbConfig });
+    }
+    return makeEnvironmentProviders(options?.enable
+        ? [
+            provideIndexedDb(dbConfig),
+            LayerDBService,
+            GeoDBService,
+            GeoNetworkService,
+            ConfigFileToGeoDBService
+        ]
+        : []);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2ZmbGluZS5wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL29mZmxpbmUvb2ZmbGluZS5wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQXdCLHdCQUF3QixFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRS9FLE9BQU8sRUFBWSxnQkFBZ0IsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRTVELE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxZQUFZLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFDakUsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUUzQyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFFN0MsTUFBTSxRQUFRLEdBQWE7SUFDekIsSUFBSSxFQUFFLFFBQVE7SUFDZCxPQUFPLEVBQUUsQ0FBQztJQUNWLGdCQUFnQixFQUFFO1FBQ2hCO1lBQ0UsS0FBSyxFQUFFLFNBQVM7WUFDaEIsV0FBVyxFQUFFLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxhQUFhLEVBQUUsS0FBSyxFQUFFO1lBQ3JELFdBQVcsRUFBRTtnQkFDWCxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsT0FBTyxFQUFFLFVBQVUsRUFBRSxPQUFPLEVBQUUsRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLEVBQUU7YUFDdEU7U0FDRjtRQUNEO1lBQ0UsS0FBSyxFQUFFLFdBQVc7WUFDbEIsV0FBVyxFQUFFLEVBQUUsT0FBTyxFQUFFLFNBQVMsRUFBRSxhQUFhLEVBQUUsS0FBSyxFQUFFO1lBQ3pELFdBQVcsRUFBRTtnQkFDWDtvQkFDRSxJQUFJLEVBQUUsY0FBYztvQkFDcEIsT0FBTyxFQUFFLGNBQWM7b0JBQ3ZCLE9BQU8sRUFBRSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUU7aUJBQzNCO2dCQUNEO29CQUNFLElBQUksRUFBRSxlQUFlO29CQUNyQixPQUFPLEVBQUUsZUFBZTtvQkFDeEIsT0FBTyxFQUFFLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRTtpQkFDM0I7YUFDRjtTQUNGO0tBQ0Y7Q0FDRixDQUFDO0FBRUYsTUFBTSxVQUFVLGNBQWMsQ0FBQyxPQUF3QjtJQUNyRCxNQUFNLGlCQUFpQixHQUFHLEVBQUUsQ0FBQztJQUM3QixLQUFLLE1BQU0sTUFBTSxJQUFJLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQztRQUNoQyxNQUFNLENBQUMsTUFBTSxDQUFDLGlCQUFpQixFQUFFLEVBQUUsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsUUFBUSxFQUFFLENBQUMsQ0FBQztJQUNoRSxDQUFDO0lBRUQsT0FBTyx3QkFBd0IsQ0FDN0IsT0FBTyxFQUFFLE1BQU07UUFDYixDQUFDLENBQUM7WUFDRSxnQkFBZ0IsQ0FBQyxRQUFRLENBQUM7WUFDMUIsY0FBYztZQUNkLFlBQVk7WUFDWixpQkFBaUI7WUFDakIsd0JBQXdCO1NBQ3pCO1FBQ0gsQ0FBQyxDQUFDLEVBQUUsQ0FDUCxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVudmlyb25tZW50UHJvdmlkZXJzLCBtYWtlRW52aXJvbm1lbnRQcm92aWRlcnMgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgREJDb25maWcsIHByb3ZpZGVJbmRleGVkRGIgfSBmcm9tICduZ3gtaW5kZXhlZC1kYic7XG5cbmltcG9ydCB7IENvbmZpZ0ZpbGVUb0dlb0RCU2VydmljZSwgR2VvREJTZXJ2aWNlIH0gZnJvbSAnLi9nZW9EQic7XG5pbXBvcnQgeyBMYXllckRCU2VydmljZSB9IGZyb20gJy4vbGF5ZXJEQic7XG5pbXBvcnQgeyBJT2ZmbGluZU9wdGlvbnMgfSBmcm9tICcuL29mZmxpbmUuaW50ZXJmYWNlJztcbmltcG9ydCB7IEdlb05ldHdvcmtTZXJ2aWNlIH0gZnJvbSAnLi9zaGFyZWQnO1xuXG5jb25zdCBkYkNvbmZpZzogREJDb25maWcgPSB7XG4gIG5hbWU6ICdpZ28yREInLFxuICB2ZXJzaW9uOiAyLFxuICBvYmplY3RTdG9yZXNNZXRhOiBbXG4gICAge1xuICAgICAgc3RvcmU6ICdnZW9EYXRhJyxcbiAgICAgIHN0b3JlQ29uZmlnOiB7IGtleVBhdGg6ICd1cmwnLCBhdXRvSW5jcmVtZW50OiBmYWxzZSB9LFxuICAgICAgc3RvcmVTY2hlbWE6IFtcbiAgICAgICAgeyBuYW1lOiAncmVnaW9uSUQnLCBrZXlwYXRoOiAncmVnaW9uSUQnLCBvcHRpb25zOiB7IHVuaXF1ZTogZmFsc2UgfSB9XG4gICAgICBdXG4gICAgfSxcbiAgICB7XG4gICAgICBzdG9yZTogJ2xheWVyRGF0YScsXG4gICAgICBzdG9yZUNvbmZpZzogeyBrZXlQYXRoOiAnbGF5ZXJJZCcsIGF1dG9JbmNyZW1lbnQ6IGZhbHNlIH0sXG4gICAgICBzdG9yZVNjaGVtYTogW1xuICAgICAgICB7XG4gICAgICAgICAgbmFtZTogJ2xheWVyT3B0aW9ucycsXG4gICAgICAgICAga2V5cGF0aDogJ2xheWVyT3B0aW9ucycsXG4gICAgICAgICAgb3B0aW9uczogeyB1bmlxdWU6IGZhbHNlIH1cbiAgICAgICAgfSxcbiAgICAgICAge1xuICAgICAgICAgIG5hbWU6ICdzb3VyY2VPcHRpb25zJyxcbiAgICAgICAgICBrZXlwYXRoOiAnc291cmNlT3B0aW9ucycsXG4gICAgICAgICAgb3B0aW9uczogeyB1bmlxdWU6IGZhbHNlIH1cbiAgICAgICAgfVxuICAgICAgXVxuICAgIH1cbiAgXVxufTtcblxuZXhwb3J0IGZ1bmN0aW9uIHByb3ZpZGVPZmZsaW5lKG9wdGlvbnM6IElPZmZsaW5lT3B0aW9ucyk6IEVudmlyb25tZW50UHJvdmlkZXJzIHtcbiAgY29uc3QgZGJDb25maWdGb3JtYXR0ZWQgPSB7fTtcbiAgZm9yIChjb25zdCBjb25maWcgb2YgW2RiQ29uZmlnXSkge1xuICAgIE9iamVjdC5hc3NpZ24oZGJDb25maWdGb3JtYXR0ZWQsIHsgW2NvbmZpZy5uYW1lXTogZGJDb25maWcgfSk7XG4gIH1cblxuICByZXR1cm4gbWFrZUVudmlyb25tZW50UHJvdmlkZXJzKFxuICAgIG9wdGlvbnM/LmVuYWJsZVxuICAgICAgPyBbXG4gICAgICAgICAgcHJvdmlkZUluZGV4ZWREYihkYkNvbmZpZyksXG4gICAgICAgICAgTGF5ZXJEQlNlcnZpY2UsXG4gICAgICAgICAgR2VvREJTZXJ2aWNlLFxuICAgICAgICAgIEdlb05ldHdvcmtTZXJ2aWNlLFxuICAgICAgICAgIENvbmZpZ0ZpbGVUb0dlb0RCU2VydmljZVxuICAgICAgICBdXG4gICAgICA6IFtdXG4gICk7XG59XG4iXX0=

package/esm2022/lib/offline/shared/geo-network.service.mjs

@@ -0,0 +1,79 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable, Optional } from '@angular/core';
+import { NetworkService } from '@igo2/core/network';
+import { GeoDBService } from '../geoDB/geoDB.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@igo2/core/network";
+import * as i3 from "../geoDB/geoDB.service";
+export var ResponseType;
+(function (ResponseType) {
+    ResponseType["Arraybuffer"] = "arraybuffer";
+    ResponseType["Blob"] = "blob";
+    ResponseType["Text"] = "text";
+    ResponseType["Json"] = "json";
+})(ResponseType || (ResponseType = {}));
+export class GeoNetworkService {
+    http;
+    networkService;
+    geoDBService;
+    networkOnline = true;
+    constructor(http, networkService, geoDBService) {
+        this.http = http;
+        this.networkService = networkService;
+        this.geoDBService = geoDBService;
+        this.networkService.currentState().subscribe((state) => {
+            this.networkOnline = state.connection;
+        });
+    }
+    get(url, simpleGetOptions) {
+        if (window.navigator.onLine && this.networkOnline) {
+            return this.getOnline(url, simpleGetOptions);
+        }
+        return this.getOffline(url);
+    }
+    getOnline(url, simpleGetOptions) {
+        let request;
+        switch (simpleGetOptions.responseType) {
+            case 'arraybuffer':
+                request = this.http.get(url, {
+                    responseType: 'arraybuffer',
+                    withCredentials: simpleGetOptions.withCredentials
+                });
+                break;
+            case 'text':
+                request = this.http.get(url, {
+                    responseType: 'text',
+                    withCredentials: simpleGetOptions.withCredentials
+                });
+                break;
+            case 'json':
+                request = this.http.get(url, {
+                    responseType: 'json',
+                    withCredentials: simpleGetOptions.withCredentials
+                });
+                break;
+            default:
+                request = this.http.get(url, {
+                    responseType: 'blob',
+                    withCredentials: simpleGetOptions.withCredentials
+                });
+                break;
+        }
+        return request;
+    }
+    getOffline(url) {
+        return this.geoDBService?.get(url);
+    }
+    isOnline() {
+        return this.networkOnline && window.navigator.onLine;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: GeoNetworkService, deps: [{ token: i1.HttpClient }, { token: i2.NetworkService }, { token: i3.GeoDBService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: GeoNetworkService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: GeoNetworkService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.NetworkService }, { type: i3.GeoDBService, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/offline/shared/index.mjs

@@ -0,0 +1,2 @@
+export * from './geo-network.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9vZmZsaW5lL3NoYXJlZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9nZW8tbmV0d29yay5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/lib/overlay/index.mjs

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

package/esm2022/lib/overlay/shared/index.mjs

@@ -0,0 +1,4 @@
+export * from './overlay';
+export * from './overlay.enum';
+export * from './overlay.utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9vdmVybGF5L3NoYXJlZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL292ZXJsYXknO1xuZXhwb3J0ICogZnJvbSAnLi9vdmVybGF5LmVudW0nO1xuZXhwb3J0ICogZnJvbSAnLi9vdmVybGF5LnV0aWxzJztcbiJdfQ==

package/esm2022/lib/overlay/shared/overlay.enum.mjs

@@ -0,0 +1,8 @@
+export var OverlayAction;
+(function (OverlayAction) {
+    OverlayAction[OverlayAction["None"] = 0] = "None";
+    OverlayAction[OverlayAction["Move"] = 1] = "Move";
+    OverlayAction[OverlayAction["Zoom"] = 2] = "Zoom";
+    OverlayAction[OverlayAction["ZoomIfOutMapExtent"] = 3] = "ZoomIfOutMapExtent";
+})(OverlayAction || (OverlayAction = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvb3ZlcmxheS9zaGFyZWQvb3ZlcmxheS5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLGFBS1g7QUFMRCxXQUFZLGFBQWE7SUFDdkIsaURBQUksQ0FBQTtJQUNKLGlEQUFJLENBQUE7SUFDSixpREFBSSxDQUFBO0lBQ0osNkVBQWtCLENBQUE7QUFDcEIsQ0FBQyxFQUxXLGFBQWEsS0FBYixhQUFhLFFBS3hCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gT3ZlcmxheUFjdGlvbiB7XG4gIE5vbmUsXG4gIE1vdmUsXG4gIFpvb20sXG4gIFpvb21JZk91dE1hcEV4dGVudFxufVxuIl19

package/esm2022/lib/overlay/shared/overlay.mjs

@@ -0,0 +1,139 @@
+import { FeatureMotion } from '../../feature/shared/feature.enums';
+import { featureToOl, moveToOlFeatures } from '../../feature/shared/feature.utils';
+import { createOverlayLayer } from './overlay.utils';
+/**
+ * This class is simply a shortcut for adding features to a map.
+ * It does nothing more than a standard layer but it's shipped with
+ * a defautl style based on the geometry type of the features it contains.
+ * @todo Enhance that by using a FeatureStore and strategies.
+ */
+export class Overlay {
+    /**
+     * The map to add the layer to
+     */
+    map;
+    /**
+     * Overlay layer
+     */
+    layer;
+    /**
+     * Overlay layer's data source
+     */
+    get dataSource() {
+        return this.layer.dataSource;
+    }
+    constructor(map) {
+        this.layer = createOverlayLayer();
+        this.setMap(map);
+    }
+    /**
+     * Bind this to a map and add the overlay layer to that map
+     * @param map Map
+     */
+    setMap(map) {
+        if (map === undefined) {
+            if (this.map !== undefined) {
+                this.map.ol.removeLayer(this.layer.ol);
+            }
+        }
+        else {
+            map.ol.addLayer(this.layer.ol);
+        }
+        this.map = map;
+    }
+    /**
+     * Set the overlay features and, optionally, move to them
+     * @param features Features
+     * @param motion Optional: Apply this motion to the map view
+     * @param sourceId Optional: Remove features of certain sourceId (ex: 'Map' for query features)
+     */
+    setFeatures(features, motion = FeatureMotion.Default, sourceId) {
+        if (sourceId) {
+            for (const olFeature of this.dataSource.ol.getFeatures()) {
+                if (olFeature.get('_sourceId') === sourceId) {
+                    this.removeOlFeature(olFeature);
+                }
+            }
+        }
+        else {
+            this.clear();
+        }
+        this.addFeatures(features, motion);
+    }
+    /**
+     * Add a feature to the  overlay and, optionally, move to it
+     * @param feature Feature
+     * @param motion Optional: Apply this motion to the map view (default on FeatureMotion.Default)
+     */
+    addFeature(feature, motion = FeatureMotion.Default) {
+        this.addFeatures([feature], motion);
+    }
+    /**
+     * Add features to the  overlay and, optionally, move to them
+     * @param features Features
+     * @param motion Optional: Apply this motion to the map view
+     */
+    addFeatures(features, motion = FeatureMotion.Default) {
+        const olFeatures = [];
+        features.forEach((feature) => {
+            const olFeature = featureToOl(feature, this.map.projection);
+            const olGeometry = olFeature.getGeometry();
+            if (olGeometry === null) {
+                return;
+            }
+            olFeatures.push(olFeature);
+        });
+        this.addOlFeatures(olFeatures, motion);
+    }
+    /**
+     * Add a OpenLayers feature to the  overlay and, optionally, move to it
+     * @param olFeature OpenLayers Feature
+     * @param motion Optional: Apply this motion to the map view
+     */
+    addOlFeature(olFeature, motion = FeatureMotion.Default) {
+        this.addOlFeatures([olFeature], motion);
+    }
+    /**
+     * Add OpenLayers features to the overlay and, optionally, move to them
+     * @param olFeatures OpenLayers Features
+     * @param motion Optional: Apply this motion to the map view
+     */
+    addOlFeatures(olFeatures, motion = FeatureMotion.Default) {
+        this.dataSource.ol.addFeatures(olFeatures);
+        moveToOlFeatures(this.map.viewController, olFeatures, motion);
+    }
+    /**
+     * Remove a feature from the overlay
+     * @param feature Feature
+     */
+    removeFeature(feature) {
+        this.removeFeatures([feature]);
+    }
+    /**
+     * Remove features from the overlay
+     * @param features Features
+     */
+    removeFeatures(features) {
+        features.forEach((feature) => {
+            if (feature.meta) {
+                if (this.dataSource.ol.getFeatureById(feature.meta.id)) {
+                    this.removeOlFeature(this.dataSource.ol.getFeatureById(feature.meta.id));
+                }
+            }
+        });
+    }
+    /**
+     * Remove an OpenLayers feature from the overlay
+     * @param olFeature OpenLayers Feature
+     */
+    removeOlFeature(olFeature) {
+        this.dataSource.ol.removeFeature(olFeature);
+    }
+    /**
+     * Clear the overlay
+     */
+    clear() {
+        this.dataSource.ol.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/overlay/shared/overlay.ts"],"names":[],"mappings":"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","sourcesContent":["import OlFeature from 'ol/Feature';\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\n\nimport { FeatureDataSource } from '../../datasource/shared/datasources';\nimport { FeatureMotion } from '../../feature/shared/feature.enums';\nimport type { Feature } from '../../feature/shared/feature.interfaces';\nimport {\n  featureToOl,\n  moveToOlFeatures\n} from '../../feature/shared/feature.utils';\nimport { VectorLayer } from '../../layer/shared/layers/vector-layer';\nimport type { MapBase } from '../../map/shared/map.abstract';\nimport { createOverlayLayer } from './overlay.utils';\n\n/**\n * This class is simply a shortcut for adding features to a map.\n * It does nothing more than a standard layer but it's shipped with\n * a defautl style based on the geometry type of the features it contains.\n * @todo Enhance that by using a FeatureStore and strategies.\n */\nexport class Overlay<T extends MapBase = MapBase> {\n  /**\n   * The map to add the layer to\n   */\n  private map: T;\n\n  /**\n   * Overlay layer\n   */\n  private layer: VectorLayer;\n\n  /**\n   * Overlay layer's data source\n   */\n  get dataSource(): FeatureDataSource {\n    return this.layer.dataSource as FeatureDataSource;\n  }\n\n  constructor(map?: T) {\n    this.layer = createOverlayLayer();\n    this.setMap(map);\n  }\n\n  /**\n   * Bind this to a map and add the overlay layer to that map\n   * @param map Map\n   */\n  setMap(map: T) {\n    if (map === undefined) {\n      if (this.map !== undefined) {\n        this.map.ol.removeLayer(this.layer.ol);\n      }\n    } else {\n      map.ol.addLayer(this.layer.ol);\n    }\n    this.map = map;\n  }\n\n  /**\n   * Set the overlay features and, optionally, move to them\n   * @param features Features\n   * @param motion Optional: Apply this motion to the map view\n   * @param sourceId Optional: Remove features of certain sourceId (ex: 'Map' for query features)\n   */\n  setFeatures(\n    features: Feature[],\n    motion: FeatureMotion = FeatureMotion.Default,\n    sourceId?: string\n  ) {\n    if (sourceId) {\n      for (const olFeature of this.dataSource.ol.getFeatures()) {\n        if (olFeature.get('_sourceId') === sourceId) {\n          this.removeOlFeature(olFeature);\n        }\n      }\n    } else {\n      this.clear();\n    }\n    this.addFeatures(features, motion);\n  }\n\n  /**\n   * Add a feature to the  overlay and, optionally, move to it\n   * @param feature Feature\n   * @param motion Optional: Apply this motion to the map view (default on FeatureMotion.Default)\n   */\n  addFeature(feature: Feature, motion: FeatureMotion = FeatureMotion.Default) {\n    this.addFeatures([feature], motion);\n  }\n\n  /**\n   * Add features to the  overlay and, optionally, move to them\n   * @param features Features\n   * @param motion Optional: Apply this motion to the map view\n   */\n  addFeatures(\n    features: Feature[],\n    motion: FeatureMotion = FeatureMotion.Default\n  ) {\n    const olFeatures = [];\n    features.forEach((feature: Feature) => {\n      const olFeature = featureToOl(feature, this.map.projection);\n      const olGeometry = olFeature.getGeometry();\n      if (olGeometry === null) {\n        return;\n      }\n      olFeatures.push(olFeature);\n    });\n\n    this.addOlFeatures(olFeatures, motion);\n  }\n\n  /**\n   * Add a OpenLayers feature to the  overlay and, optionally, move to it\n   * @param olFeature OpenLayers Feature\n   * @param motion Optional: Apply this motion to the map view\n   */\n  addOlFeature(\n    olFeature: OlFeature<OlGeometry>,\n    motion: FeatureMotion = FeatureMotion.Default\n  ) {\n    this.addOlFeatures([olFeature], motion);\n  }\n\n  /**\n   * Add OpenLayers features to the overlay and, optionally, move to them\n   * @param olFeatures OpenLayers Features\n   * @param motion Optional: Apply this motion to the map view\n   */\n  addOlFeatures(\n    olFeatures: OlFeature<OlGeometry>[],\n    motion: FeatureMotion = FeatureMotion.Default\n  ) {\n    this.dataSource.ol.addFeatures(olFeatures);\n    moveToOlFeatures(this.map.viewController, olFeatures, motion);\n  }\n\n  /**\n   * Remove a feature from the overlay\n   * @param feature Feature\n   */\n  removeFeature(feature: Feature) {\n    this.removeFeatures([feature]);\n  }\n\n  /**\n   * Remove features from the overlay\n   * @param features Features\n   */\n  removeFeatures(features: Feature[]) {\n    features.forEach((feature: Feature) => {\n      if (feature.meta) {\n        if (this.dataSource.ol.getFeatureById(feature.meta.id)) {\n          this.removeOlFeature(\n            this.dataSource.ol.getFeatureById(feature.meta.id)\n          );\n        }\n      }\n    });\n  }\n\n  /**\n   * Remove an OpenLayers feature from the overlay\n   * @param olFeature OpenLayers Feature\n   */\n  removeOlFeature(olFeature: OlFeature<OlGeometry>) {\n    this.dataSource.ol.removeFeature(olFeature);\n  }\n\n  /**\n   * Clear the overlay\n   */\n  clear() {\n    this.dataSource.ol.clear();\n  }\n}\n"]}

package/esm2022/lib/overlay/shared/overlay.utils.mjs

@@ -0,0 +1,17 @@
+import { FeatureDataSource } from '../../datasource/shared/datasources';
+import { VectorLayer } from '../../layer/shared/layers/vector-layer';
+import { createOverlayLayerStyle } from '../../style/shared/overlay/overlay-style.utils';
+/**
+ * Create an overlay layer and it's source
+ * @returns Overlay layer
+ */
+export function createOverlayLayer() {
+    const overlayDataSource = new FeatureDataSource();
+    return new VectorLayer({
+        title: 'Overlay',
+        zIndex: 300,
+        source: overlayDataSource,
+        style: createOverlayLayerStyle()
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS51dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL292ZXJsYXkvc2hhcmVkL292ZXJsYXkudXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDeEUsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQ3JFLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLGdEQUFnRCxDQUFDO0FBRXpGOzs7R0FHRztBQUNILE1BQU0sVUFBVSxrQkFBa0I7SUFDaEMsTUFBTSxpQkFBaUIsR0FBRyxJQUFJLGlCQUFpQixFQUFFLENBQUM7SUFDbEQsT0FBTyxJQUFJLFdBQVcsQ0FBQztRQUNyQixLQUFLLEVBQUUsU0FBUztRQUNoQixNQUFNLEVBQUUsR0FBRztRQUNYLE1BQU0sRUFBRSxpQkFBaUI7UUFDekIsS0FBSyxFQUFFLHVCQUF1QixFQUFFO0tBQ2pDLENBQUMsQ0FBQztBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGZWF0dXJlRGF0YVNvdXJjZSB9IGZyb20gJy4uLy4uL2RhdGFzb3VyY2Uvc2hhcmVkL2RhdGFzb3VyY2VzJztcbmltcG9ydCB7IFZlY3RvckxheWVyIH0gZnJvbSAnLi4vLi4vbGF5ZXIvc2hhcmVkL2xheWVycy92ZWN0b3ItbGF5ZXInO1xuaW1wb3J0IHsgY3JlYXRlT3ZlcmxheUxheWVyU3R5bGUgfSBmcm9tICcuLi8uLi9zdHlsZS9zaGFyZWQvb3ZlcmxheS9vdmVybGF5LXN0eWxlLnV0aWxzJztcblxuLyoqXG4gKiBDcmVhdGUgYW4gb3ZlcmxheSBsYXllciBhbmQgaXQncyBzb3VyY2VcbiAqIEByZXR1cm5zIE92ZXJsYXkgbGF5ZXJcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZU92ZXJsYXlMYXllcigpOiBWZWN0b3JMYXllciB7XG4gIGNvbnN0IG92ZXJsYXlEYXRhU291cmNlID0gbmV3IEZlYXR1cmVEYXRhU291cmNlKCk7XG4gIHJldHVybiBuZXcgVmVjdG9yTGF5ZXIoe1xuICAgIHRpdGxlOiAnT3ZlcmxheScsXG4gICAgekluZGV4OiAzMDAsXG4gICAgc291cmNlOiBvdmVybGF5RGF0YVNvdXJjZSxcbiAgICBzdHlsZTogY3JlYXRlT3ZlcmxheUxheWVyU3R5bGUoKVxuICB9KTtcbn1cbiJdfQ==

package/esm2022/lib/print/index.mjs

@@ -0,0 +1,4 @@
+export * from './shared';
+export * from './print/print.component';
+export * from './print-form';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9wcmludC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zaGFyZWQnO1xuZXhwb3J0ICogZnJvbSAnLi9wcmludC9wcmludC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9wcmludC1mb3JtJztcbiJdfQ==

package/esm2022/lib/print/print/print.component.mjs

@@ -0,0 +1,116 @@
+import { Component, Input } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { take } from 'rxjs/operators';
+import { IgoMap } from '../../map/shared/map';
+import { PrintFormComponent } from '../print-form/print-form.component';
+import { PrintService } from '../shared/print.service';
+import { PrintLegendPosition, PrintOrientation, PrintOutputFormat, PrintPaperFormat, PrintResolution, PrintSaveImageFormat } from '../shared/print.type';
+import * as i0 from "@angular/core";
+import * as i1 from "../shared/print.service";
+export class PrintComponent {
+    printService;
+    disabled$ = new BehaviorSubject(false);
+    get map() {
+        return this._map;
+    }
+    set map(value) {
+        this._map = value;
+    }
+    _map;
+    get outputFormat() {
+        return this._outputFormat;
+    }
+    set outputFormat(value) {
+        this._outputFormat = value;
+    }
+    _outputFormat;
+    get paperFormat() {
+        return this._paperFormat;
+    }
+    set paperFormat(value) {
+        this._paperFormat = value;
+    }
+    _paperFormat;
+    get orientation() {
+        return this._orientation;
+    }
+    set orientation(value) {
+        this._orientation = value;
+    }
+    _orientation;
+    get imageFormat() {
+        return this._imageFormat;
+    }
+    set imageFormat(value) {
+        this._imageFormat = value;
+    }
+    _imageFormat;
+    get legendPosition() {
+        return this._legendPosition;
+    }
+    set legendPosition(value) {
+        this._legendPosition = value;
+    }
+    _legendPosition;
+    get resolution() {
+        return this._resolution;
+    }
+    set resolution(value) {
+        this._resolution = value;
+    }
+    _resolution;
+    constructor(printService) {
+        this.printService = printService;
+    }
+    handleFormSubmit(data) {
+        this.disabled$.next(true);
+        if (data.isPrintService === true) {
+            this.printService
+                .print(this.map, data)
+                .pipe(take(1))
+                .subscribe(() => {
+                this.disabled$.next(false);
+            });
+        }
+        else {
+            let nbFileToProcess = 1;
+            if (data.showLegend) {
+                nbFileToProcess++;
+            }
+            if (data.imageFormat.toLowerCase() === 'tiff') {
+                nbFileToProcess++;
+            }
+            if (data.legendPosition === 'newpage') {
+                nbFileToProcess++;
+            }
+            this.printService.defineNbFileToProcess(nbFileToProcess);
+            this.printService
+                .downloadMapImage(this.map, data.resolution, data.imageFormat, data.showProjection, data.showScale, data.title, data.subtitle, data.comment, data.doZipFile, data.legendPosition, data.showNorthArrow)
+                .pipe(take(1))
+                .subscribe(() => {
+                this.disabled$.next(false);
+            });
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PrintComponent, deps: [{ token: i1.PrintService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: PrintComponent, isStandalone: true, selector: "igo-print", inputs: { map: "map", outputFormat: "outputFormat", paperFormat: "paperFormat", orientation: "orientation", imageFormat: "imageFormat", legendPosition: "legendPosition", resolution: "resolution" }, ngImport: i0, template: "<igo-print-form\n  [outputFormat]=\"outputFormat\"\n  [paperFormat]=\"paperFormat\"\n  [orientation]=\"orientation\"\n  [imageFormat]=\"imageFormat\"\n  [resolution]=\"resolution\"\n  [legendPosition]=\"legendPosition\"\n  [disabled$]=\"disabled$\"\n  (submit)=\"handleFormSubmit($event)\"\n>\n</igo-print-form>\n", dependencies: [{ kind: "component", type: PrintFormComponent, selector: "igo-print-form", inputs: ["disabled$", "imageFormat", "outputFormat", "paperFormat", "orientation", "resolution", "legendPosition", "title", "subtitle", "comment", "showProjection", "showScale", "showLegend", "doZipFile", "showNorth"], outputs: ["submit"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PrintComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'igo-print', standalone: true, imports: [PrintFormComponent], template: "<igo-print-form\n  [outputFormat]=\"outputFormat\"\n  [paperFormat]=\"paperFormat\"\n  [orientation]=\"orientation\"\n  [imageFormat]=\"imageFormat\"\n  [resolution]=\"resolution\"\n  [legendPosition]=\"legendPosition\"\n  [disabled$]=\"disabled$\"\n  (submit)=\"handleFormSubmit($event)\"\n>\n</igo-print-form>\n" }]
+        }], ctorParameters: () => [{ type: i1.PrintService }], propDecorators: { map: [{
+                type: Input
+            }], outputFormat: [{
+                type: Input
+            }], paperFormat: [{
+                type: Input
+            }], orientation: [{
+                type: Input
+            }], imageFormat: [{
+                type: Input
+            }], legendPosition: [{
+                type: Input
+            }], resolution: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"print.component.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/print/print/print.component.ts","../../../../../../packages/geo/src/lib/print/print/print.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input } from '@angular/core';\n\nimport { BehaviorSubject } from 'rxjs';\nimport { take } from 'rxjs/operators';\n\nimport { IgoMap } from '../../map/shared/map';\nimport { PrintFormComponent } from '../print-form/print-form.component';\nimport { PrintOptions } from '../shared/print.interface';\nimport { PrintService } from '../shared/print.service';\nimport {\n  PrintLegendPosition,\n  PrintOrientation,\n  PrintOutputFormat,\n  PrintPaperFormat,\n  PrintResolution,\n  PrintSaveImageFormat\n} from '../shared/print.type';\n\n@Component({\n  selector: 'igo-print',\n  templateUrl: './print.component.html',\n  standalone: true,\n  imports: [PrintFormComponent]\n})\nexport class PrintComponent {\n  public disabled$ = new BehaviorSubject(false);\n\n  @Input()\n  get map(): IgoMap {\n    return this._map;\n  }\n  set map(value: IgoMap) {\n    this._map = value;\n  }\n  private _map: IgoMap;\n\n  @Input()\n  get outputFormat(): PrintOutputFormat {\n    return this._outputFormat;\n  }\n  set outputFormat(value: PrintOutputFormat) {\n    this._outputFormat = value;\n  }\n  private _outputFormat: PrintOutputFormat;\n\n  @Input()\n  get paperFormat(): PrintPaperFormat {\n    return this._paperFormat;\n  }\n  set paperFormat(value: PrintPaperFormat) {\n    this._paperFormat = value;\n  }\n  private _paperFormat: PrintPaperFormat;\n\n  @Input()\n  get orientation(): PrintOrientation {\n    return this._orientation;\n  }\n  set orientation(value: PrintOrientation) {\n    this._orientation = value;\n  }\n  private _orientation: PrintOrientation;\n\n  @Input()\n  get imageFormat(): PrintSaveImageFormat {\n    return this._imageFormat;\n  }\n  set imageFormat(value: PrintSaveImageFormat) {\n    this._imageFormat = value;\n  }\n  private _imageFormat: PrintSaveImageFormat;\n\n  @Input()\n  get legendPosition(): PrintLegendPosition {\n    return this._legendPosition;\n  }\n  set legendPosition(value: PrintLegendPosition) {\n    this._legendPosition = value;\n  }\n  private _legendPosition: PrintLegendPosition;\n\n  @Input()\n  get resolution(): PrintResolution {\n    return this._resolution;\n  }\n  set resolution(value: PrintResolution) {\n    this._resolution = value;\n  }\n  private _resolution: PrintResolution;\n\n  constructor(private printService: PrintService) {}\n\n  handleFormSubmit(data: PrintOptions) {\n    this.disabled$.next(true);\n\n    if (data.isPrintService === true) {\n      this.printService\n        .print(this.map, data)\n        .pipe(take(1))\n        .subscribe(() => {\n          this.disabled$.next(false);\n        });\n    } else {\n      let nbFileToProcess = 1;\n\n      if (data.showLegend) {\n        nbFileToProcess++;\n      }\n      if (data.imageFormat.toLowerCase() === 'tiff') {\n        nbFileToProcess++;\n      }\n\n      if (data.legendPosition === 'newpage') {\n        nbFileToProcess++;\n      }\n\n      this.printService.defineNbFileToProcess(nbFileToProcess);\n\n      this.printService\n        .downloadMapImage(\n          this.map,\n          data.resolution,\n          data.imageFormat,\n          data.showProjection,\n          data.showScale,\n          data.title,\n          data.subtitle,\n          data.comment,\n          data.doZipFile,\n          data.legendPosition,\n          data.showNorthArrow\n        )\n        .pipe(take(1))\n        .subscribe(() => {\n          this.disabled$.next(false);\n        });\n    }\n  }\n}\n","<igo-print-form\n  [outputFormat]=\"outputFormat\"\n  [paperFormat]=\"paperFormat\"\n  [orientation]=\"orientation\"\n  [imageFormat]=\"imageFormat\"\n  [resolution]=\"resolution\"\n  [legendPosition]=\"legendPosition\"\n  [disabled$]=\"disabled$\"\n  (submit)=\"handleFormSubmit($event)\"\n>\n</igo-print-form>\n"]}

package/esm2022/lib/print/print-form/index.mjs

@@ -0,0 +1,2 @@
+export * from './print-form.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9wcmludC9wcmludC1mb3JtL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0JBQXdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3ByaW50LWZvcm0uY29tcG9uZW50JztcbiJdfQ==