@igo2/geo 1.11.1 → 1.13.0-alpha.0

package/esm2020/lib/metadata/metadata-button/metadata-button.component.mjs

@@ -0,0 +1,134 @@
+import { Component, Input, ChangeDetectionStrategy, Inject, ViewEncapsulation } from '@angular/core';
+import { MAT_DIALOG_DATA } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+import * as i1 from "../shared/metadata.service";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/icon";
+import * as i5 from "@angular/material/button";
+import * as i6 from "@angular/material/tooltip";
+import * as i7 from "@ngx-translate/core";
+function MetadataButtonComponent_button_0_Template(rf, ctx) { if (rf & 1) {
+    const _r2 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "button", 1);
+    i0.ɵɵlistener("click", function MetadataButtonComponent_button_0_Template_button_click_0_listener() { i0.ɵɵrestoreView(_r2); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.openMetadata(ctx_r1.options.metadata)); });
+    i0.ɵɵpipe(1, "translate");
+    i0.ɵɵelement(2, "mat-icon", 2);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("matTooltip", i0.ɵɵpipeBind1(1, 2, "igo.geo.metadata.show"))("color", ctx_r0.color);
+} }
+function MetadataAbstractComponent_mat_dialog_content_4_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "mat-dialog-content", 3)(1, "h3");
+    i0.ɵɵtext(2);
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(ctx_r0.data.abstract);
+} }
+function MetadataAbstractComponent_mat_dialog_content_5_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "mat-dialog-content", 3);
+    i0.ɵɵelement(1, "h3", 4);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("innerHTML", ctx_r1.data.abstract, i0.ɵɵsanitizeHtml);
+} }
+export class MetadataButtonComponent {
+    constructor(metadataService, dialog) {
+        this.metadataService = metadataService;
+        this.dialog = dialog;
+        this._color = 'primary';
+    }
+    get layer() {
+        return this._layer;
+    }
+    set layer(value) {
+        this._layer = value;
+    }
+    get color() {
+        return this._color;
+    }
+    set color(value) {
+        this._color = value;
+    }
+    openMetadata(metadata) {
+        if (metadata.extern) {
+            if (!metadata.url && metadata.abstract) {
+                this.dialog.open(MetadataAbstractComponent, {
+                    data: {
+                        layerTitle: this.layer.title,
+                        abstract: metadata.abstract,
+                        type: metadata.type
+                    }
+                });
+            }
+            else if (metadata.url) {
+                this.metadataService.open(metadata);
+            }
+        }
+        else if (!metadata.extern && metadata.abstract) {
+            this.dialog.open(MetadataAbstractComponent, {
+                data: {
+                    layerTitle: this.layer.title,
+                    abstract: metadata.abstract,
+                    type: metadata.type
+                }
+            });
+        }
+    }
+    get options() {
+        if (!this.layer) {
+            return;
+        }
+        return this.layer.options;
+    }
+}
+MetadataButtonComponent.ɵfac = function MetadataButtonComponent_Factory(t) { return new (t || MetadataButtonComponent)(i0.ɵɵdirectiveInject(i1.MetadataService), i0.ɵɵdirectiveInject(i2.MatDialog)); };
+MetadataButtonComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: MetadataButtonComponent, selectors: [["igo-metadata-button"]], inputs: { layer: "layer", color: "color" }, decls: 1, vars: 1, consts: [["mat-icon-button", "", "tooltip-position", "below", "matTooltipShowDelay", "500", 3, "matTooltip", "color", "click", 4, "ngIf"], ["mat-icon-button", "", "tooltip-position", "below", "matTooltipShowDelay", "500", 3, "matTooltip", "color", "click"], ["svgIcon", "information-outline"]], template: function MetadataButtonComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵtemplate(0, MetadataButtonComponent_button_0_Template, 3, 4, "button", 0);
+    } if (rf & 2) {
+        i0.ɵɵproperty("ngIf", ctx.options && ctx.options.metadata && ctx.options.metadata.url || ctx.options && ctx.options.metadata && ctx.options.metadata.abstract);
+    } }, dependencies: [i3.NgIf, i4.MatIcon, i5.MatButton, i6.MatTooltip, i7.TranslatePipe], changeDetection: 0 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MetadataButtonComponent, [{
+        type: Component,
+        args: [{ selector: 'igo-metadata-button', changeDetection: ChangeDetectionStrategy.OnPush, template: "<button\r\n  *ngIf=\"(options && options.metadata && options.metadata.url) || (options && options.metadata && options.metadata.abstract)\"\r\n  mat-icon-button\r\n  tooltip-position=\"below\"\r\n  matTooltipShowDelay=\"500\"\r\n  [matTooltip]=\"'igo.geo.metadata.show' | translate\"\r\n  [color]=\"color\"\r\n  (click)=\"openMetadata(options.metadata)\">\r\n  <mat-icon svgIcon=\"information-outline\"></mat-icon>\r\n</button>\r\n" }]
+    }], function () { return [{ type: i1.MetadataService }, { type: i2.MatDialog }]; }, { layer: [{
+            type: Input
+        }], color: [{
+            type: Input
+        }] }); })();
+export class MetadataAbstractComponent {
+    constructor(data) {
+        this.data = data;
+    }
+}
+MetadataAbstractComponent.ɵfac = function MetadataAbstractComponent_Factory(t) { return new (t || MetadataAbstractComponent)(i0.ɵɵdirectiveInject(MAT_DIALOG_DATA)); };
+MetadataAbstractComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: MetadataAbstractComponent, selectors: [["igo-metadata-abstract"]], decls: 6, vars: 3, consts: [["mat-dialog-title", ""], ["mat-button", "", "mat-dialog-close", "", 1, "close-button"], ["class", "mat-typography", 4, "ngIf"], [1, "mat-typography"], [3, "innerHTML"]], template: function MetadataAbstractComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "h2", 0);
+        i0.ɵɵtext(1);
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(2, "button", 1);
+        i0.ɵɵtext(3, "X");
+        i0.ɵɵelementEnd();
+        i0.ɵɵtemplate(4, MetadataAbstractComponent_mat_dialog_content_4_Template, 3, 1, "mat-dialog-content", 2);
+        i0.ɵɵtemplate(5, MetadataAbstractComponent_mat_dialog_content_5_Template, 2, 1, "mat-dialog-content", 2);
+    } if (rf & 2) {
+        i0.ɵɵadvance(1);
+        i0.ɵɵtextInterpolate(ctx.data.layerTitle);
+        i0.ɵɵadvance(3);
+        i0.ɵɵproperty("ngIf", ctx.data.type !== "arcgisrest");
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", ctx.data.type === "arcgisrest");
+    } }, dependencies: [i3.NgIf, i5.MatButton, i2.MatDialogClose, i2.MatDialogTitle, i2.MatDialogContent], styles: [".close-button{top:5px;right:5px;padding:7px;line-height:10px;position:absolute!important;min-width:auto}mat-dialog-container{position:relative}\n"], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MetadataAbstractComponent, [{
+        type: Component,
+        args: [{ selector: 'igo-metadata-abstract', encapsulation: ViewEncapsulation.None, template: "<h2 mat-dialog-title>{{ data.layerTitle }}</h2>\r\n<button class=\"close-button\" mat-button mat-dialog-close>X</button>\r\n<mat-dialog-content *ngIf=\"data.type !== 'arcgisrest'\" class=\"mat-typography\">\r\n  <h3>{{ data.abstract }}</h3>\r\n</mat-dialog-content>\r\n<mat-dialog-content *ngIf=\"data.type === 'arcgisrest'\" class=\"mat-typography\">\r\n  <h3 [innerHTML]=\"data.abstract\"></h3>\r\n</mat-dialog-content>\r\n", styles: [".close-button{top:5px;right:5px;padding:7px;line-height:10px;position:absolute!important;min-width:auto}mat-dialog-container{position:relative}\n"] }]
+    }], function () { return [{ type: undefined, decorators: [{
+                type: Inject,
+                args: [MAT_DIALOG_DATA]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/metadata/metadata.module.mjs

@@ -0,0 +1,55 @@
+import { MatDialogModule } from '@angular/material/dialog';
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { IgoLanguageModule } from '@igo2/core';
+import { MetadataButtonComponent, MetadataAbstractComponent } from './metadata-button/metadata-button.component';
+import * as i0 from "@angular/core";
+export class IgoMetadataModule {
+    static forRoot() {
+        return {
+            ngModule: IgoMetadataModule,
+            providers: []
+        };
+    }
+}
+IgoMetadataModule.ɵfac = function IgoMetadataModule_Factory(t) { return new (t || IgoMetadataModule)(); };
+IgoMetadataModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoMetadataModule });
+IgoMetadataModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
+        MatIconModule,
+        MatButtonModule,
+        MatTooltipModule,
+        IgoLanguageModule,
+        MatDialogModule] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoMetadataModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    MatIconModule,
+                    MatButtonModule,
+                    MatTooltipModule,
+                    IgoLanguageModule,
+                    MatDialogModule
+                ],
+                exports: [
+                    MetadataButtonComponent,
+                    MetadataAbstractComponent
+                ],
+                declarations: [
+                    MetadataButtonComponent,
+                    MetadataAbstractComponent
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IgoMetadataModule, { declarations: [MetadataButtonComponent,
+        MetadataAbstractComponent], imports: [CommonModule,
+        MatIconModule,
+        MatButtonModule,
+        MatTooltipModule,
+        IgoLanguageModule,
+        MatDialogModule], exports: [MetadataButtonComponent,
+        MetadataAbstractComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/metadata/shared/index.mjs

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

package/esm2020/lib/metadata/shared/metadata.interface.mjs

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

package/esm2020/lib/metadata/shared/metadata.service.mjs

@@ -0,0 +1,19 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MetadataService {
+    constructor() { }
+    open(metadata) {
+        if (metadata.extern) {
+            window.open(metadata.url, '_blank');
+        }
+    }
+}
+MetadataService.ɵfac = function MetadataService_Factory(t) { return new (t || MetadataService)(); };
+MetadataService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: MetadataService, factory: MetadataService.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MetadataService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return []; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0YWRhdGEuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL21ldGFkYXRhL3NoYXJlZC9tZXRhZGF0YS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTzNDLE1BQU0sT0FBTyxlQUFlO0lBQzFCLGdCQUFlLENBQUM7SUFFaEIsSUFBSSxDQUFDLFFBQXlCO1FBQzVCLElBQUksUUFBUSxDQUFDLE1BQU0sRUFBRTtZQUNuQixNQUFNLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLEVBQUUsUUFBUSxDQUFDLENBQUM7U0FDckM7SUFDSCxDQUFDOzs4RUFQVSxlQUFlO3FFQUFmLGVBQWUsV0FBZixlQUFlLG1CQUZkLE1BQU07dUZBRVAsZUFBZTtjQUgzQixVQUFVO2VBQUM7Z0JBQ1YsVUFBVSxFQUFFLE1BQU07YUFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5pbXBvcnQgeyBNZXRhZGF0YU9wdGlvbnMgfSBmcm9tICcuL21ldGFkYXRhLmludGVyZmFjZSc7XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBNZXRhZGF0YVNlcnZpY2Uge1xyXG4gIGNvbnN0cnVjdG9yKCkge31cclxuXHJcbiAgb3BlbihtZXRhZGF0YTogTWV0YWRhdGFPcHRpb25zKSB7XHJcbiAgICBpZiAobWV0YWRhdGEuZXh0ZXJuKSB7XHJcbiAgICAgIHdpbmRvdy5vcGVuKG1ldGFkYXRhLnVybCwgJ19ibGFuaycpO1xyXG4gICAgfVxyXG4gIH1cclxufVxyXG4iXX0=

package/esm2020/lib/offline/geoDB/geoDB.enums.mjs

@@ -0,0 +1,6 @@
+export var InsertSourceInsertDBEnum;
+(function (InsertSourceInsertDBEnum) {
+    InsertSourceInsertDBEnum["System"] = "system";
+    InsertSourceInsertDBEnum["User"] = "user";
+})(InsertSourceInsertDBEnum || (InsertSourceInsertDBEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VvREIuZW51bXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9vZmZsaW5lL2dlb0RCL2dlb0RCLmVudW1zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLHdCQUdUO0FBSEgsV0FBWSx3QkFBd0I7SUFDaEMsNkNBQWlCLENBQUE7SUFDakIseUNBQWEsQ0FBQTtBQUNmLENBQUMsRUFIUyx3QkFBd0IsS0FBeEIsd0JBQXdCLFFBR2pDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gSW5zZXJ0U291cmNlSW5zZXJ0REJFbnVtIHtcclxuICAgIFN5c3RlbSA9ICdzeXN0ZW0nLFxyXG4gICAgVXNlciA9ICd1c2VyJ1xyXG4gIH1cclxuIl19

package/esm2020/lib/offline/geoDB/geoDB.interface.mjs

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

package/esm2020/lib/offline/geoDB/geoDB.service.mjs

@@ -0,0 +1,161 @@
+import { Injectable } from '@angular/core';
+import { DBMode } from 'ngx-indexed-db';
+import { of, Subject } from 'rxjs';
+import { concatMap, first, map, take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-indexed-db";
+import * as i2 from "@igo2/core";
+export class GeoDBService {
+    constructor(ngxIndexedDBService, compression) {
+        this.ngxIndexedDBService = ngxIndexedDBService;
+        this.compression = compression;
+        this.dbName = 'geoData';
+        this.collisionsMap = new Map();
+        this._newTiles = 0;
+    }
+    /**
+     * Only blob can be will be compressed
+     * @param url
+     * @param regionID
+     * @param object object to handle
+     * @param insertSource type of event user or system
+     * @param insertEvent Name of the event where the insert has been triggered
+     * @returns
+     */
+    update(url, regionID, object, insertSource, insertEvent) {
+        if (!object) {
+            return;
+        }
+        let compress = false;
+        const subject = new Subject();
+        let object$ = of(object);
+        if (object instanceof Blob) {
+            object$ = this.compression.compressBlob(object);
+            compress = true;
+        }
+        let geoDBData;
+        object$.pipe(first(), concatMap(object => {
+            geoDBData = {
+                url,
+                regionID,
+                object: object,
+                compressed: compress,
+                insertSource,
+                insertEvent
+            };
+            return this.ngxIndexedDBService.getByID(this.dbName, url);
+        }), concatMap((dbObject) => {
+            if (!dbObject) {
+                this._newTiles++;
+                return this.ngxIndexedDBService.add(this.dbName, geoDBData);
+            }
+            else {
+                const currentRegionID = dbObject.regionID;
+                if (currentRegionID !== regionID) {
+                    const collisions = this.collisionsMap.get(currentRegionID);
+                    if (collisions !== undefined) {
+                        collisions.push(dbObject.url);
+                        this.collisionsMap.set(currentRegionID, collisions);
+                    }
+                    else {
+                        this.collisionsMap.set(currentRegionID, [dbObject.url]);
+                    }
+                }
+                return this.customUpdate(geoDBData);
+            }
+        })).subscribe((response) => {
+            subject.next(response);
+            subject.complete();
+        });
+        return subject;
+    }
+    customUpdate(geoDBData) {
+        const subject = new Subject();
+        const deleteRequest = this.ngxIndexedDBService.deleteByKey(this.dbName, geoDBData.url);
+        deleteRequest.pipe(concatMap(isDeleted => isDeleted ? this.ngxIndexedDBService.add(this.dbName, geoDBData) : of(undefined)))
+            .subscribe(object => {
+            if (object) {
+                subject.next(object);
+            }
+            subject.complete();
+        });
+        return subject;
+    }
+    get(url) {
+        return this.ngxIndexedDBService.getByID(this.dbName, url).pipe(map((data) => {
+            if (data) {
+                const object = data.object;
+                if (!data.compressed) {
+                    return object;
+                }
+                return this.compression.decompressBlob(object);
+            }
+        }));
+    }
+    getRegionTileCountByID(id) {
+        const subject = new Subject();
+        const dbRequest = this.getRegionByID(id)
+            .subscribe((tiles) => {
+            subject.next(tiles.length);
+            subject.complete();
+        });
+        return subject;
+    }
+    getRegionByID(id) {
+        if (!id) {
+            return;
+        }
+        const IDBKey = IDBKeyRange.only(id);
+        const dbRequest = this.ngxIndexedDBService.getAllByIndex(this.dbName, 'regionID', IDBKey);
+        return dbRequest;
+    }
+    deleteByRegionID(id) {
+        if (!id) {
+            return;
+        }
+        const IDBKey = IDBKeyRange.only(id);
+        const dbRequest = this.ngxIndexedDBService.getAllByIndex(this.dbName, 'regionID', IDBKey);
+        dbRequest.subscribe((tiles) => {
+            tiles.forEach((tile) => {
+                this.ngxIndexedDBService.deleteByKey(this.dbName, tile.url);
+            });
+        });
+        return dbRequest;
+    }
+    openCursor(keyRange = IDBKeyRange.lowerBound(0), mode = DBMode.readonly) {
+        const request = this.ngxIndexedDBService.openCursorByIndex(this.dbName, 'regionID', keyRange, mode);
+        return request;
+    }
+    resetCounters() {
+        this.resetCollisionsMap();
+        this._newTiles = 0;
+    }
+    resetCollisionsMap() {
+        this.collisionsMap = new Map();
+    }
+    revertCollisions() {
+        for (const [regionID, collisions] of this.collisionsMap) {
+            for (const url of collisions) {
+                this.ngxIndexedDBService.getByKey(this.dbName, url)
+                    .pipe(take(1))
+                    .subscribe((dbObject) => {
+                    const updatedObject = dbObject;
+                    updatedObject.regionID = regionID;
+                    this.customUpdate(dbObject);
+                });
+            }
+        }
+    }
+    get newTiles() {
+        return this._newTiles;
+    }
+}
+GeoDBService.ɵfac = function GeoDBService_Factory(t) { return new (t || GeoDBService)(i0.ɵɵinject(i1.NgxIndexedDBService), i0.ɵɵinject(i2.CompressionService)); };
+GeoDBService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: GeoDBService, factory: GeoDBService.ɵfac, providedIn: 'root' });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(GeoDBService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.NgxIndexedDBService }, { type: i2.CompressionService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geoDB.service.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/offline/geoDB/geoDB.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { DBMode, NgxIndexedDBService } from 'ngx-indexed-db';\r\nimport { Observable, of, Subject } from 'rxjs';\r\nimport { concatMap, first, map, take } from 'rxjs/operators';\r\nimport { CompressionService } from '@igo2/core';\r\nimport { GeoDBData } from './geoDB.interface';\r\nimport { InsertSourceInsertDBEnum } from './geoDB.enums';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class GeoDBService {\r\n  readonly dbName: string = 'geoData';\r\n  public collisionsMap: Map<number, string[]> = new Map();\r\n  public _newTiles: number = 0;\r\n\r\n  constructor(\r\n    private ngxIndexedDBService: NgxIndexedDBService,\r\n    private compression: CompressionService\r\n  ) { }\r\n\r\n  /**\r\n   * Only blob can be will be compressed\r\n   * @param url\r\n   * @param regionID\r\n   * @param object object to handle\r\n   * @param insertSource type of event user or system\r\n   * @param insertEvent Name of the event where the insert has been triggered\r\n   * @returns\r\n   */\r\n  update(url: string, regionID: number, object: any, insertSource: InsertSourceInsertDBEnum, insertEvent: string): Observable<any> {\r\n    if (!object) {\r\n      return;\r\n    }\r\n    let compress = false;\r\n\r\n    const subject: Subject<GeoDBData> = new Subject();\r\n    let object$: Observable<any> = of(object);\r\n    if (object instanceof Blob) {\r\n      object$ = this.compression.compressBlob(object);\r\n      compress = true;\r\n    }\r\n    let geoDBData: GeoDBData;\r\n    object$.pipe(\r\n      first(),\r\n      concatMap(object => {\r\n        geoDBData = {\r\n          url,\r\n          regionID,\r\n          object: object,\r\n          compressed: compress,\r\n          insertSource,\r\n          insertEvent\r\n        };\r\n        return this.ngxIndexedDBService.getByID(this.dbName, url);\r\n      }),\r\n      concatMap((dbObject: GeoDBData) => {\r\n        if (!dbObject) {\r\n          this._newTiles++;\r\n          return this.ngxIndexedDBService.add(this.dbName, geoDBData);\r\n        } else {\r\n          const currentRegionID = dbObject.regionID;\r\n          if (currentRegionID !== regionID) {\r\n            const collisions = this.collisionsMap.get(currentRegionID);\r\n            if (collisions !== undefined) {\r\n              collisions.push(dbObject.url);\r\n              this.collisionsMap.set(currentRegionID, collisions);\r\n            } else {\r\n              this.collisionsMap.set(currentRegionID, [dbObject.url]);\r\n            }\r\n          }\r\n          return this.customUpdate(geoDBData);\r\n        }\r\n      })\r\n    ).subscribe((response) => {\r\n      subject.next(response);\r\n      subject.complete();\r\n    });\r\n    return subject;\r\n  }\r\n\r\n  private customUpdate(geoDBData: GeoDBData): Observable<GeoDBData> {\r\n    const subject: Subject<GeoDBData> = new Subject();\r\n    const deleteRequest = this.ngxIndexedDBService.deleteByKey(this.dbName, geoDBData.url);\r\n    deleteRequest.pipe(\r\n      concatMap(isDeleted => isDeleted ? this.ngxIndexedDBService.add(this.dbName, geoDBData) : of(undefined))\r\n    )\r\n    .subscribe(object => {\r\n      if (object) {\r\n        subject.next(object);\r\n      }\r\n      subject.complete();\r\n    });\r\n    return subject;\r\n  }\r\n\r\n  get(url: string): Observable<any> {\r\n    return this.ngxIndexedDBService.getByID(this.dbName, url).pipe(\r\n      map((data: GeoDBData) => {\r\n        if (data) {\r\n          const object = data.object;\r\n          if (!data.compressed) {\r\n            return object;\r\n          }\r\n          return this.compression.decompressBlob(object);\r\n        }\r\n      })\r\n    );\r\n  }\r\n\r\n  getRegionTileCountByID(id: number): Observable<number> {\r\n    const subject: Subject<number> = new Subject();\r\n    const dbRequest = this.getRegionByID(id)\r\n      .subscribe((tiles) => {\r\n        subject.next(tiles.length);\r\n        subject.complete();\r\n      });\r\n    return subject;\r\n  }\r\n\r\n  getRegionByID(id: number): Observable<any[]> {\r\n    if (!id) {\r\n      return;\r\n    }\r\n\r\n    const IDBKey: IDBKeyRange = IDBKeyRange.only(id);\r\n    const dbRequest = this.ngxIndexedDBService.getAllByIndex(this.dbName, 'regionID', IDBKey);\r\n    return dbRequest;\r\n  }\r\n\r\n  deleteByRegionID(id: number): Observable<any> {\r\n    if (!id) {\r\n      return;\r\n    }\r\n\r\n    const IDBKey: IDBKeyRange = IDBKeyRange.only(id);\r\n    const dbRequest = this.ngxIndexedDBService.getAllByIndex(this.dbName, 'regionID', IDBKey);\r\n    dbRequest.subscribe((tiles: GeoDBData[]) => {\r\n      tiles.forEach((tile) => {\r\n        this.ngxIndexedDBService.deleteByKey(this.dbName, tile.url);\r\n      });\r\n    });\r\n    return dbRequest;\r\n  }\r\n\r\n  openCursor(\r\n    keyRange: IDBKeyRange = IDBKeyRange.lowerBound(0),\r\n    mode: DBMode = DBMode.readonly\r\n  ) {\r\n    const request = this.ngxIndexedDBService.openCursorByIndex(this.dbName, 'regionID', keyRange, mode);\r\n    return request;\r\n  }\r\n\r\n  resetCounters() {\r\n    this.resetCollisionsMap();\r\n    this._newTiles = 0;\r\n  }\r\n\r\n  resetCollisionsMap() {\r\n    this.collisionsMap = new Map();\r\n  }\r\n\r\n  revertCollisions() {\r\n    for (const [regionID, collisions] of this.collisionsMap) {\r\n      for (const url of collisions) {\r\n        this.ngxIndexedDBService.getByKey(this.dbName, url)\r\n          .pipe(take(1))\r\n          .subscribe((dbObject: GeoDBData) => {\r\n            const updatedObject = dbObject;\r\n            updatedObject.regionID = regionID;\r\n            this.customUpdate(dbObject);\r\n          });\r\n      }\r\n    }\r\n  }\r\n\r\n  get newTiles(): number {\r\n    return this._newTiles;\r\n  }\r\n}\r\n"]}

package/esm2020/lib/offline/geoDB/index.mjs

@@ -0,0 +1,4 @@
+export * from './geoDB.enums';
+export * from './geoDB.interface';
+export * from './geoDB.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9vZmZsaW5lL2dlb0RCL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZ2VvREIuZW51bXMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2dlb0RCLmludGVyZmFjZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZ2VvREIuc2VydmljZSc7XHJcbiJdfQ==

package/esm2020/lib/offline/index.mjs

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

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

@@ -0,0 +1,66 @@
+import { Injectable } from '@angular/core';
+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 {
+    constructor(http, geoDBService, networkService) {
+        this.http = http;
+        this.geoDBService = geoDBService;
+        this.networkService = networkService;
+        this.networkOnline = true;
+        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;
+    }
+}
+GeoNetworkService.ɵfac = function GeoNetworkService_Factory(t) { return new (t || GeoNetworkService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.GeoDBService), i0.ɵɵinject(i3.NetworkService)); };
+GeoNetworkService.ɵ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/esm2020/lib/offline/shared/index.mjs

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

package/esm2020/lib/overlay/index.mjs

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

package/esm2020/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
+        };
+    }
+}
+IgoOverlayModule.ɵfac = function IgoOverlayModule_Factory(t) { return new (t || IgoOverlayModule)(); };
+IgoOverlayModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoOverlayModule });
+IgoOverlayModule.ɵ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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9vdmVybGF5L292ZXJsYXkubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQXVCLE1BQU0sZUFBZSxDQUFDO0FBRTlELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDOztBQU85RCxNQUFNLE9BQU8sZ0JBQWdCO0lBQzNCLE1BQU0sQ0FBQyxPQUFPO1FBQ1osT0FBTztZQUNMLFFBQVEsRUFBRSxnQkFBZ0I7U0FDM0IsQ0FBQztJQUNKLENBQUM7O2dGQUxVLGdCQUFnQjtrRUFBaEIsZ0JBQWdCOzt1RkFBaEIsZ0JBQWdCO2NBTDVCLFFBQVE7ZUFBQztnQkFDUixPQUFPLEVBQUUsRUFBRTtnQkFDWCxPQUFPLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQztnQkFDM0IsWUFBWSxFQUFFLENBQUMsZ0JBQWdCLENBQUM7YUFDakM7O3dGQUNZLGdCQUFnQixtQkFGWixnQkFBZ0IsYUFEckIsZ0JBQWdCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUsIE1vZHVsZVdpdGhQcm92aWRlcnMgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbmltcG9ydCB7IE92ZXJsYXlEaXJlY3RpdmUgfSBmcm9tICcuL3NoYXJlZC9vdmVybGF5LmRpcmVjdGl2ZSc7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gIGltcG9ydHM6IFtdLFxyXG4gIGV4cG9ydHM6IFtPdmVybGF5RGlyZWN0aXZlXSxcclxuICBkZWNsYXJhdGlvbnM6IFtPdmVybGF5RGlyZWN0aXZlXVxyXG59KVxyXG5leHBvcnQgY2xhc3MgSWdvT3ZlcmxheU1vZHVsZSB7XHJcbiAgc3RhdGljIGZvclJvb3QoKTogTW9kdWxlV2l0aFByb3ZpZGVyczxJZ29PdmVybGF5TW9kdWxlPiB7XHJcbiAgICByZXR1cm4ge1xyXG4gICAgICBuZ01vZHVsZTogSWdvT3ZlcmxheU1vZHVsZVxyXG4gICAgfTtcclxuICB9XHJcbn1cclxuIl19

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

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