@igo2/geo 1.15.3 → 16.0.0-rc.0

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

@@ -0,0 +1,3 @@
+export * from './layerDB.interface';
+export * from './layerDB.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9vZmZsaW5lL2xheWVyREIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9sYXllckRCLmludGVyZmFjZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGF5ZXJEQi5zZXJ2aWNlJztcclxuIl19

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

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

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

@@ -0,0 +1,84 @@
+import { Injectable } from '@angular/core';
+import { NgxIndexedDBService } from 'ngx-indexed-db';
+import { of, Subject } 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 = function LayerDBService_Factory(t) { return new (t || LayerDBService)(i0.ɵɵinject(i1.NgxIndexedDBService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: LayerDBService, factory: LayerDBService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LayerDBService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.NgxIndexedDBService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF5ZXJEQi5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvb2ZmbGluZS9sYXllckRCL2xheWVyREIuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3JELE9BQU8sRUFBYyxFQUFFLEVBQUUsT0FBTyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQy9DLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7OztBQU1sRCxNQUFNLE9BQU8sY0FBYztJQUdMO0lBRlgsTUFBTSxHQUFXLFdBQVcsQ0FBQztJQUV0QyxZQUFvQixtQkFBd0M7UUFBeEMsd0JBQW1CLEdBQW5CLG1CQUFtQixDQUFxQjtJQUFHLENBQUM7SUFFaEU7Ozs7T0FJRztJQUNILE1BQU0sQ0FBQyxXQUF3QjtRQUM3QixNQUFNLE9BQU8sR0FBeUIsSUFBSSxPQUFPLEVBQUUsQ0FBQztRQUNwRCxJQUFJLENBQUMsbUJBQW1CO2FBQ3JCLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLFdBQVcsQ0FBQyxPQUFPLENBQUM7YUFDekMsSUFBSSxDQUNILEtBQUssRUFBRSxFQUNQLFNBQVMsQ0FBQyxDQUFDLFFBQXFCLEVBQUUsRUFBRTtZQUNsQyxJQUFJLENBQUMsUUFBUSxFQUFFO2dCQUNiLE9BQU8sSUFBSSxDQUFDLG1CQUFtQixDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLFdBQVcsQ0FBQyxDQUFDO2FBQy9EO2lCQUFNO2dCQUNMLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxXQUFXLENBQUMsQ0FBQzthQUN2QztRQUNILENBQUMsQ0FBQyxDQUNIO2FBQ0EsU0FBUyxDQUFDLENBQUMsUUFBUSxFQUFFLEVBQUU7WUFDdEIsT0FBTyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUN2QixPQUFPLENBQUMsUUFBUSxFQUFFLENBQUM7UUFDckIsQ0FBQyxDQUFDLENBQUM7UUFDTCxPQUFPLE9BQU8sQ0FBQztJQUNqQixDQUFDO0lBRU8sWUFBWSxDQUFDLFdBQXdCO1FBQzNDLE1BQU0sT0FBTyxHQUF5QixJQUFJLE9BQU8sRUFBRSxDQUFDO1FBQ3BELE1BQU0sYUFBYSxHQUFHLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxXQUFXLENBQ3hELElBQUksQ0FBQyxNQUFNLEVBQ1gsV0FBVyxDQUFDLE9BQU8sQ0FDcEIsQ0FBQztRQUNGLGFBQWE7YUFDVixJQUFJLENBQ0gsU0FBUyxDQUFDLENBQUMsU0FBUyxFQUFFLEVBQUUsQ0FDdEIsU0FBUztZQUNQLENBQUMsQ0FBQyxJQUFJLENBQUMsbUJBQW1CLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsV0FBVyxDQUFDO1lBQ3hELENBQUMsQ0FBQyxFQUFFLENBQUMsU0FBUyxDQUFDLENBQ2xCLENBQ0Y7YUFDQSxTQUFTLENBQUMsQ0FBQyxNQUFNLEVBQUUsRUFBRTtZQUNwQixJQUFJLE1BQU0sRUFBRTtnQkFDVixPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO2FBQ3RCO1lBQ0QsT0FBTyxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ3JCLENBQUMsQ0FBQyxDQUFDO1FBQ0wsT0FBTyxPQUFPLENBQUM7SUFDakIsQ0FBQztJQUVEOzs7O09BSUc7SUFDSCxPQUFPLENBQUMsT0FBZTtRQUNyQixPQUFPLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxPQUFPLENBQUMsQ0FBQztJQUNoRSxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILFdBQVcsQ0FBQyxPQUFlO1FBQ3pCLE9BQU8sSUFBSSxDQUFDLG1CQUFtQixDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ3BFLENBQUM7SUFFRDs7OztPQUlHO0lBQ0gsTUFBTTtRQUNKLE9BQU8sSUFBSSxDQUFDLG1CQUFtQixDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDdEQsQ0FBQzt3RUEvRVUsY0FBYztnRUFBZCxjQUFjLFdBQWQsY0FBYyxtQkFGYixNQUFNOzt1RkFFUCxjQUFjO2NBSDFCLFVBQVU7ZUFBQztnQkFDVixVQUFVLEVBQUUsTUFBTTthQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgTmd4SW5kZXhlZERCU2VydmljZSB9IGZyb20gJ25neC1pbmRleGVkLWRiJztcclxuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgb2YsIFN1YmplY3QgfSBmcm9tICdyeGpzJztcclxuaW1wb3J0IHsgY29uY2F0TWFwLCBmaXJzdCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcclxuaW1wb3J0IHsgTGF5ZXJEQkRhdGEgfSBmcm9tICcuL2xheWVyREIuaW50ZXJmYWNlJztcclxuXHJcbkBJbmplY3RhYmxlKHtcclxuICBwcm92aWRlZEluOiAncm9vdCdcclxufSlcclxuZXhwb3J0IGNsYXNzIExheWVyREJTZXJ2aWNlIHtcclxuICByZWFkb25seSBkYk5hbWU6IHN0cmluZyA9ICdsYXllckRhdGEnO1xyXG5cclxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIG5neEluZGV4ZWREQlNlcnZpY2U6IE5neEluZGV4ZWREQlNlcnZpY2UpIHt9XHJcblxyXG4gIC8qKlxyXG4gICAqIFRoaXMgbWV0aG9kIGFsbG93IHRvIHVwZGF0ZSB0aGUgc3RvcmVkIGxheWVyIGludG8gdGhlIGluZGV4ZWRkYiAobGF5ZXJEYXRhKVxyXG4gICAqIEBwYXJhbSBsYXllckRCRGF0YVxyXG4gICAqIEByZXR1cm5zXHJcbiAgICovXHJcbiAgdXBkYXRlKGxheWVyREJEYXRhOiBMYXllckRCRGF0YSk6IE9ic2VydmFibGU8YW55PiB7XHJcbiAgICBjb25zdCBzdWJqZWN0OiBTdWJqZWN0PExheWVyREJEYXRhPiA9IG5ldyBTdWJqZWN0KCk7XHJcbiAgICB0aGlzLm5neEluZGV4ZWREQlNlcnZpY2VcclxuICAgICAgLmdldEJ5SUQodGhpcy5kYk5hbWUsIGxheWVyREJEYXRhLmxheWVySWQpXHJcbiAgICAgIC5waXBlKFxyXG4gICAgICAgIGZpcnN0KCksXHJcbiAgICAgICAgY29uY2F0TWFwKChkYk9iamVjdDogTGF5ZXJEQkRhdGEpID0+IHtcclxuICAgICAgICAgIGlmICghZGJPYmplY3QpIHtcclxuICAgICAgICAgICAgcmV0dXJuIHRoaXMubmd4SW5kZXhlZERCU2VydmljZS5hZGQodGhpcy5kYk5hbWUsIGxheWVyREJEYXRhKTtcclxuICAgICAgICAgIH0gZWxzZSB7XHJcbiAgICAgICAgICAgIHJldHVybiB0aGlzLmN1c3RvbVVwZGF0ZShsYXllckRCRGF0YSk7XHJcbiAgICAgICAgICB9XHJcbiAgICAgICAgfSlcclxuICAgICAgKVxyXG4gICAgICAuc3Vic2NyaWJlKChyZXNwb25zZSkgPT4ge1xyXG4gICAgICAgIHN1YmplY3QubmV4dChyZXNwb25zZSk7XHJcbiAgICAgICAgc3ViamVjdC5jb21wbGV0ZSgpO1xyXG4gICAgICB9KTtcclxuICAgIHJldHVybiBzdWJqZWN0O1xyXG4gIH1cclxuXHJcbiAgcHJpdmF0ZSBjdXN0b21VcGRhdGUobGF5ZXJEQkRhdGE6IExheWVyREJEYXRhKTogT2JzZXJ2YWJsZTxMYXllckRCRGF0YT4ge1xyXG4gICAgY29uc3Qgc3ViamVjdDogU3ViamVjdDxMYXllckRCRGF0YT4gPSBuZXcgU3ViamVjdCgpO1xyXG4gICAgY29uc3QgZGVsZXRlUmVxdWVzdCA9IHRoaXMubmd4SW5kZXhlZERCU2VydmljZS5kZWxldGVCeUtleShcclxuICAgICAgdGhpcy5kYk5hbWUsXHJcbiAgICAgIGxheWVyREJEYXRhLmxheWVySWRcclxuICAgICk7XHJcbiAgICBkZWxldGVSZXF1ZXN0XHJcbiAgICAgIC5waXBlKFxyXG4gICAgICAgIGNvbmNhdE1hcCgoaXNEZWxldGVkKSA9PlxyXG4gICAgICAgICAgaXNEZWxldGVkXHJcbiAgICAgICAgICAgID8gdGhpcy5uZ3hJbmRleGVkREJTZXJ2aWNlLmFkZCh0aGlzLmRiTmFtZSwgbGF5ZXJEQkRhdGEpXHJcbiAgICAgICAgICAgIDogb2YodW5kZWZpbmVkKVxyXG4gICAgICAgIClcclxuICAgICAgKVxyXG4gICAgICAuc3Vic2NyaWJlKChvYmplY3QpID0+IHtcclxuICAgICAgICBpZiAob2JqZWN0KSB7XHJcbiAgICAgICAgICBzdWJqZWN0Lm5leHQob2JqZWN0KTtcclxuICAgICAgICB9XHJcbiAgICAgICAgc3ViamVjdC5jb21wbGV0ZSgpO1xyXG4gICAgICB9KTtcclxuICAgIHJldHVybiBzdWJqZWN0O1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogVGhpcyBtZXRob2QgcmV0cmlldmUgYW4gaWRiIGxheWVyIGRlZmluaXRpb25cclxuICAgKiBAcGFyYW0gbGF5ZXJJZFxyXG4gICAqIEByZXR1cm5zXHJcbiAgICovXHJcbiAgZ2V0QnlJRChsYXllcklkOiBzdHJpbmcpOiBPYnNlcnZhYmxlPExheWVyREJEYXRhPiB7XHJcbiAgICByZXR1cm4gdGhpcy5uZ3hJbmRleGVkREJTZXJ2aWNlLmdldEJ5SUQodGhpcy5kYk5hbWUsIGxheWVySWQpO1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogVGhpcyBtZXRob2QgZGVsZXRlIGFuIGlkYiBsYXllciBkZWZpbml0aW9uXHJcbiAgICogQHBhcmFtIGxheWVySWRcclxuICAgKiBAcmV0dXJuc1xyXG4gICAqL1xyXG4gIGRlbGV0ZUJ5S2V5KGxheWVySWQ6IHN0cmluZyk6IE9ic2VydmFibGU8Ym9vbGVhbj4ge1xyXG4gICAgcmV0dXJuIHRoaXMubmd4SW5kZXhlZERCU2VydmljZS5kZWxldGVCeUtleSh0aGlzLmRiTmFtZSwgbGF5ZXJJZCk7XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBUaGlzIG1ldGhvZCByZXRyaXZlIGFsbCBpZGIgbGF5ZXIgZGVmaW5pdGlvblxyXG4gICAqIEBwYXJhbSBsYXllcklkXHJcbiAgICogQHJldHVybnNcclxuICAgKi9cclxuICBnZXRBbGwoKTogT2JzZXJ2YWJsZTxMYXllckRCRGF0YVtdPiB7XHJcbiAgICByZXR1cm4gdGhpcy5uZ3hJbmRleGVkREJTZXJ2aWNlLmdldEFsbCh0aGlzLmRiTmFtZSk7XHJcbiAgfVxyXG59XHJcbiJdfQ==

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

@@ -0,0 +1,87 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { NetworkService } from '@igo2/core';
+import { GeoDBService } from '../geoDB/geoDB.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../geoDB/geoDB.service";
+import * as i3 from "@igo2/core";
+export var ResponseType;
+(function (ResponseType) {
+    ResponseType["Arraybuffer"] = "arraybuffer";
+    ResponseType["Blob"] = "blob";
+    ResponseType["Text"] = "text";
+    ResponseType["Json"] = "json";
+})(ResponseType || (ResponseType = {}));
+export class GeoNetworkService {
+    http;
+    geoDBService;
+    networkService;
+    networkOnline = true;
+    constructor(http, geoDBService, networkService) {
+        this.http = http;
+        this.geoDBService = geoDBService;
+        this.networkService = networkService;
+        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) {
+            // TODO Ajuster pour autre formats
+            case 'arraybuffer':
+                request = this.http.get(url, {
+                    responseType: 'arraybuffer',
+                    withCredentials: simpleGetOptions.withCredentials
+                });
+                break;
+            case 'blob':
+                request = this.http.get(url, {
+                    responseType: 'blob',
+                    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 = function GeoNetworkService_Factory(t) { return new (t || GeoNetworkService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.GeoDBService), i0.ɵɵinject(i3.NetworkService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: GeoNetworkService, factory: GeoNetworkService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(GeoNetworkService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.GeoDBService }, { type: i3.NetworkService }]; }, null); })();
+//# 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/overlay.module.mjs

@@ -0,0 +1,23 @@
+import { NgModule } from '@angular/core';
+import { OverlayDirective } from './shared/overlay.directive';
+import * as i0 from "@angular/core";
+export class IgoOverlayModule {
+    static forRoot() {
+        return {
+            ngModule: IgoOverlayModule
+        };
+    }
+    static ɵfac = function IgoOverlayModule_Factory(t) { return new (t || IgoOverlayModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoOverlayModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({});
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoOverlayModule, [{
+        type: NgModule,
+        args: [{
+                imports: [],
+                exports: [OverlayDirective],
+                declarations: [OverlayDirective]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IgoOverlayModule, { declarations: [OverlayDirective], exports: [OverlayDirective] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9vdmVybGF5L292ZXJsYXkubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQXVCLE1BQU0sZUFBZSxDQUFDO0FBRTlELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDOztBQU85RCxNQUFNLE9BQU8sZ0JBQWdCO0lBQzNCLE1BQU0sQ0FBQyxPQUFPO1FBQ1osT0FBTztZQUNMLFFBQVEsRUFBRSxnQkFBZ0I7U0FDM0IsQ0FBQztJQUNKLENBQUM7MEVBTFUsZ0JBQWdCOzREQUFoQixnQkFBZ0I7Ozt1RkFBaEIsZ0JBQWdCO2NBTDVCLFFBQVE7ZUFBQztnQkFDUixPQUFPLEVBQUUsRUFBRTtnQkFDWCxPQUFPLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQztnQkFDM0IsWUFBWSxFQUFFLENBQUMsZ0JBQWdCLENBQUM7YUFDakM7O3dGQUNZLGdCQUFnQixtQkFGWixnQkFBZ0IsYUFEckIsZ0JBQWdCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUsIE1vZHVsZVdpdGhQcm92aWRlcnMgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgT3ZlcmxheURpcmVjdGl2ZSB9IGZyb20gJy4vc2hhcmVkL292ZXJsYXkuZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW10sXG4gIGV4cG9ydHM6IFtPdmVybGF5RGlyZWN0aXZlXSxcbiAgZGVjbGFyYXRpb25zOiBbT3ZlcmxheURpcmVjdGl2ZV1cbn0pXG5leHBvcnQgY2xhc3MgSWdvT3ZlcmxheU1vZHVsZSB7XG4gIHN0YXRpYyBmb3JSb290KCk6IE1vZHVsZVdpdGhQcm92aWRlcnM8SWdvT3ZlcmxheU1vZHVsZT4ge1xuICAgIHJldHVybiB7XG4gICAgICBuZ01vZHVsZTogSWdvT3ZlcmxheU1vZHVsZVxuICAgIH07XG4gIH1cbn1cbiJdfQ==

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

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

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

@@ -0,0 +1,38 @@
+import { Directive, Self } from '@angular/core';
+import olFormatGeoJSON from 'ol/format/GeoJSON';
+import { MapBrowserComponent } from '../../map/map-browser/map-browser.component';
+import { OverlayService } from '../shared/overlay.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../map/map-browser/map-browser.component";
+import * as i2 from "../shared/overlay.service";
+export class OverlayDirective {
+    component;
+    overlayService;
+    features$$;
+    format = new olFormatGeoJSON();
+    get map() {
+        return this.component.map;
+    }
+    constructor(component, overlayService) {
+        this.component = component;
+        this.overlayService = overlayService;
+    }
+    ngOnInit() {
+        this.features$$ = this.overlayService.features$.subscribe((res) => this.handleFeatures(res[0], res[1]));
+    }
+    ngOnDestroy() {
+        this.features$$.unsubscribe();
+    }
+    handleFeatures(features, action) { }
+    static ɵfac = function OverlayDirective_Factory(t) { return new (t || OverlayDirective)(i0.ɵɵdirectiveInject(i1.MapBrowserComponent, 2), i0.ɵɵdirectiveInject(i2.OverlayService)); };
+    static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: OverlayDirective, selectors: [["", "igoOverlay", ""]] });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(OverlayDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[igoOverlay]'
+            }]
+    }], function () { return [{ type: i1.MapBrowserComponent, decorators: [{
+                type: Self
+            }] }, { type: i2.OverlayService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9vdmVybGF5L3NoYXJlZC9vdmVybGF5LmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBcUIsTUFBTSxlQUFlLENBQUM7QUFHbkUsT0FBTyxlQUFlLE1BQU0sbUJBQW1CLENBQUM7QUFHaEQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sNkNBQTZDLENBQUM7QUFHbEYsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLDJCQUEyQixDQUFDOzs7O0FBTTNELE1BQU0sT0FBTyxnQkFBZ0I7SUFTVDtJQUNSO0lBVEYsVUFBVSxDQUFlO0lBQ3pCLE1BQU0sR0FBRyxJQUFJLGVBQWUsRUFBRSxDQUFDO0lBRXZDLElBQUksR0FBRztRQUNMLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUM7SUFDNUIsQ0FBQztJQUVELFlBQ2tCLFNBQThCLEVBQ3RDLGNBQThCO1FBRHRCLGNBQVMsR0FBVCxTQUFTLENBQXFCO1FBQ3RDLG1CQUFjLEdBQWQsY0FBYyxDQUFnQjtJQUNyQyxDQUFDO0lBRUosUUFBUTtRQUNOLElBQUksQ0FBQyxVQUFVLEdBQUcsSUFBSSxDQUFDLGNBQWMsQ0FBQyxTQUFTLENBQUMsU0FBUyxDQUFDLENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FDaEUsSUFBSSxDQUFDLGNBQWMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQ3BDLENBQUM7SUFDSixDQUFDO0lBRUQsV0FBVztRQUNULElBQUksQ0FBQyxVQUFVLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDaEMsQ0FBQztJQUVPLGNBQWMsQ0FBQyxRQUFtQixFQUFFLE1BQXFCLElBQUcsQ0FBQzswRUF2QjFELGdCQUFnQjs2REFBaEIsZ0JBQWdCOzt1RkFBaEIsZ0JBQWdCO2NBSDVCLFNBQVM7ZUFBQztnQkFDVCxRQUFRLEVBQUUsY0FBYzthQUN6Qjs7c0JBVUksSUFBSSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgU2VsZiwgT25Jbml0LCBPbkRlc3Ryb3kgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgU3Vic2NyaXB0aW9uIH0gZnJvbSAncnhqcyc7XHJcblxyXG5pbXBvcnQgb2xGb3JtYXRHZW9KU09OIGZyb20gJ29sL2Zvcm1hdC9HZW9KU09OJztcclxuXHJcbmltcG9ydCB7IElnb01hcCB9IGZyb20gJy4uLy4uL21hcC9zaGFyZWQvbWFwJztcclxuaW1wb3J0IHsgTWFwQnJvd3NlckNvbXBvbmVudCB9IGZyb20gJy4uLy4uL21hcC9tYXAtYnJvd3Nlci9tYXAtYnJvd3Nlci5jb21wb25lbnQnO1xyXG5pbXBvcnQgeyBGZWF0dXJlIH0gZnJvbSAnLi4vLi4vZmVhdHVyZS9zaGFyZWQvZmVhdHVyZS5pbnRlcmZhY2VzJztcclxuXHJcbmltcG9ydCB7IE92ZXJsYXlTZXJ2aWNlIH0gZnJvbSAnLi4vc2hhcmVkL292ZXJsYXkuc2VydmljZSc7XHJcbmltcG9ydCB7IE92ZXJsYXlBY3Rpb24gfSBmcm9tICcuLi9zaGFyZWQvb3ZlcmxheS5lbnVtJztcclxuXHJcbkBEaXJlY3RpdmUoe1xyXG4gIHNlbGVjdG9yOiAnW2lnb092ZXJsYXldJ1xyXG59KVxyXG5leHBvcnQgY2xhc3MgT3ZlcmxheURpcmVjdGl2ZSBpbXBsZW1lbnRzIE9uSW5pdCwgT25EZXN0cm95IHtcclxuICBwcml2YXRlIGZlYXR1cmVzJCQ6IFN1YnNjcmlwdGlvbjtcclxuICBwcml2YXRlIGZvcm1hdCA9IG5ldyBvbEZvcm1hdEdlb0pTT04oKTtcclxuXHJcbiAgZ2V0IG1hcCgpOiBJZ29NYXAge1xyXG4gICAgcmV0dXJuIHRoaXMuY29tcG9uZW50Lm1hcDtcclxuICB9XHJcblxyXG4gIGNvbnN0cnVjdG9yKFxyXG4gICAgQFNlbGYoKSBwcml2YXRlIGNvbXBvbmVudDogTWFwQnJvd3NlckNvbXBvbmVudCxcclxuICAgIHByaXZhdGUgb3ZlcmxheVNlcnZpY2U6IE92ZXJsYXlTZXJ2aWNlXHJcbiAgKSB7fVxyXG5cclxuICBuZ09uSW5pdCgpIHtcclxuICAgIHRoaXMuZmVhdHVyZXMkJCA9IHRoaXMub3ZlcmxheVNlcnZpY2UuZmVhdHVyZXMkLnN1YnNjcmliZSgocmVzKSA9PlxyXG4gICAgICB0aGlzLmhhbmRsZUZlYXR1cmVzKHJlc1swXSwgcmVzWzFdKVxyXG4gICAgKTtcclxuICB9XHJcblxyXG4gIG5nT25EZXN0cm95KCkge1xyXG4gICAgdGhpcy5mZWF0dXJlcyQkLnVuc3Vic2NyaWJlKCk7XHJcbiAgfVxyXG5cclxuICBwcml2YXRlIGhhbmRsZUZlYXR1cmVzKGZlYXR1cmVzOiBGZWF0dXJlW10sIGFjdGlvbjogT3ZlcmxheUFjdGlvbikge31cclxufVxyXG4iXX0=

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvb3ZlcmxheS9zaGFyZWQvb3ZlcmxheS5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLGFBS1g7QUFMRCxXQUFZLGFBQWE7SUFDdkIsaURBQUksQ0FBQTtJQUNKLGlEQUFJLENBQUE7SUFDSixpREFBSSxDQUFBO0lBQ0osNkVBQWtCLENBQUE7QUFDcEIsQ0FBQyxFQUxXLGFBQWEsS0FBYixhQUFhLFFBS3hCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gT3ZlcmxheUFjdGlvbiB7XHJcbiAgTm9uZSxcclxuICBNb3ZlLFxyXG4gIFpvb20sXHJcbiAgWm9vbUlmT3V0TWFwRXh0ZW50XHJcbn1cclxuIl19

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

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

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

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { OverlayAction } from './overlay.enum';
+import * as i0 from "@angular/core";
+export class OverlayService {
+    features$ = new BehaviorSubject([
+        [],
+        undefined
+    ]);
+    constructor() { }
+    setFeatures(features, action = OverlayAction.None) {
+        this.features$.next([features, action]);
+    }
+    clear() {
+        this.features$.next([[], OverlayAction.None]);
+    }
+    static ɵfac = function OverlayService_Factory(t) { return new (t || OverlayService)(); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: OverlayService, factory: OverlayService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(OverlayService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return []; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZ2VvL3NyYy9saWIvb3ZlcmxheS9zaGFyZWQvb3ZlcmxheS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUl2QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7O0FBSy9DLE1BQU0sT0FBTyxjQUFjO0lBQ2xCLFNBQVMsR0FBRyxJQUFJLGVBQWUsQ0FBNkI7UUFDakUsRUFBRTtRQUNGLFNBQVM7S0FDVixDQUFDLENBQUM7SUFFSCxnQkFBZSxDQUFDO0lBRWhCLFdBQVcsQ0FBQyxRQUFtQixFQUFFLFNBQXdCLGFBQWEsQ0FBQyxJQUFJO1FBQ3pFLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLENBQUMsUUFBUSxFQUFFLE1BQU0sQ0FBQyxDQUFDLENBQUM7SUFDMUMsQ0FBQztJQUVELEtBQUs7UUFDSCxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxDQUFDLEVBQUUsRUFBRSxhQUFhLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztJQUNoRCxDQUFDO3dFQWRVLGNBQWM7Z0VBQWQsY0FBYyxXQUFkLGNBQWMsbUJBRmIsTUFBTTs7dUZBRVAsY0FBYztjQUgxQixVQUFVO2VBQUM7Z0JBQ1YsVUFBVSxFQUFFLE1BQU07YUFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBCZWhhdmlvclN1YmplY3QgfSBmcm9tICdyeGpzJztcblxuaW1wb3J0IHsgRmVhdHVyZSB9IGZyb20gJy4uLy4uL2ZlYXR1cmUvc2hhcmVkL2ZlYXR1cmUuaW50ZXJmYWNlcyc7XG5cbmltcG9ydCB7IE92ZXJsYXlBY3Rpb24gfSBmcm9tICcuL292ZXJsYXkuZW51bSc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIE92ZXJsYXlTZXJ2aWNlIHtcbiAgcHVibGljIGZlYXR1cmVzJCA9IG5ldyBCZWhhdmlvclN1YmplY3Q8W0ZlYXR1cmVbXSwgT3ZlcmxheUFjdGlvbl0+KFtcbiAgICBbXSxcbiAgICB1bmRlZmluZWRcbiAgXSk7XG5cbiAgY29uc3RydWN0b3IoKSB7fVxuXG4gIHNldEZlYXR1cmVzKGZlYXR1cmVzOiBGZWF0dXJlW10sIGFjdGlvbjogT3ZlcmxheUFjdGlvbiA9IE92ZXJsYXlBY3Rpb24uTm9uZSkge1xuICAgIHRoaXMuZmVhdHVyZXMkLm5leHQoW2ZlYXR1cmVzLCBhY3Rpb25dKTtcbiAgfVxuXG4gIGNsZWFyKCkge1xuICAgIHRoaXMuZmVhdHVyZXMkLm5leHQoW1tdLCBPdmVybGF5QWN0aW9uLk5vbmVdKTtcbiAgfVxufVxuIl19

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

@@ -0,0 +1,17 @@
+import { FeatureDataSource } from '../../datasource';
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS51dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL292ZXJsYXkvc2hhcmVkL292ZXJsYXkudXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDckQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQ3JFLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLGdEQUFnRCxDQUFDO0FBRXpGOzs7R0FHRztBQUNILE1BQU0sVUFBVSxrQkFBa0I7SUFDaEMsTUFBTSxpQkFBaUIsR0FBRyxJQUFJLGlCQUFpQixFQUFFLENBQUM7SUFDbEQsT0FBTyxJQUFJLFdBQVcsQ0FBQztRQUNyQixLQUFLLEVBQUUsU0FBUztRQUNoQixNQUFNLEVBQUUsR0FBRztRQUNYLE1BQU0sRUFBRSxpQkFBaUI7UUFDekIsS0FBSyxFQUFFLHVCQUF1QixFQUFFO0tBQ2pDLENBQUMsQ0FBQztBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGZWF0dXJlRGF0YVNvdXJjZSB9IGZyb20gJy4uLy4uL2RhdGFzb3VyY2UnO1xyXG5pbXBvcnQgeyBWZWN0b3JMYXllciB9IGZyb20gJy4uLy4uL2xheWVyL3NoYXJlZC9sYXllcnMvdmVjdG9yLWxheWVyJztcclxuaW1wb3J0IHsgY3JlYXRlT3ZlcmxheUxheWVyU3R5bGUgfSBmcm9tICcuLi8uLi9zdHlsZS9zaGFyZWQvb3ZlcmxheS9vdmVybGF5LXN0eWxlLnV0aWxzJztcclxuXHJcbi8qKlxyXG4gKiBDcmVhdGUgYW4gb3ZlcmxheSBsYXllciBhbmQgaXQncyBzb3VyY2VcclxuICogQHJldHVybnMgT3ZlcmxheSBsYXllclxyXG4gKi9cclxuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZU92ZXJsYXlMYXllcigpOiBWZWN0b3JMYXllciB7XHJcbiAgY29uc3Qgb3ZlcmxheURhdGFTb3VyY2UgPSBuZXcgRmVhdHVyZURhdGFTb3VyY2UoKTtcclxuICByZXR1cm4gbmV3IFZlY3RvckxheWVyKHtcclxuICAgIHRpdGxlOiAnT3ZlcmxheScsXHJcbiAgICB6SW5kZXg6IDMwMCxcclxuICAgIHNvdXJjZTogb3ZlcmxheURhdGFTb3VyY2UsXHJcbiAgICBzdHlsZTogY3JlYXRlT3ZlcmxheUxheWVyU3R5bGUoKVxyXG4gIH0pO1xyXG59XHJcbiJdfQ==

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==