@igo2/geo 1.15.4 → 16.0.0-rc.1

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

@@ -0,0 +1,140 @@
+import { Component, Input, ChangeDetectionStrategy, Inject, ViewEncapsulation } from '@angular/core';
+import { MatDialog, MAT_DIALOG_DATA } from '@angular/material/dialog';
+import { Layer } from '../../layer/shared/layers/layer';
+import { MetadataService } from '../shared/metadata.service';
+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 {
+    metadataService;
+    dialog;
+    get layer() {
+        return this._layer;
+    }
+    set layer(value) {
+        this._layer = value;
+    }
+    _layer;
+    get color() {
+        return this._color;
+    }
+    set color(value) {
+        this._color = value;
+    }
+    _color = 'primary';
+    constructor(metadataService, dialog) {
+        this.metadataService = metadataService;
+        this.dialog = dialog;
+    }
+    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;
+    }
+    static ɵfac = function MetadataButtonComponent_Factory(t) { return new (t || MetadataButtonComponent)(i0.ɵɵdirectiveInject(i1.MetadataService), i0.ɵɵdirectiveInject(i2.MatDialog)); };
+    static ɵ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.MatIconButton, 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\n  *ngIf=\"\n    (options && options.metadata && options.metadata.url) ||\n    (options && options.metadata && options.metadata.abstract)\n  \"\n  mat-icon-button\n  tooltip-position=\"below\"\n  matTooltipShowDelay=\"500\"\n  [matTooltip]=\"'igo.geo.metadata.show' | translate\"\n  [color]=\"color\"\n  (click)=\"openMetadata(options.metadata)\"\n>\n  <mat-icon svgIcon=\"information-outline\"></mat-icon>\n</button>\n" }]
+    }], function () { return [{ type: i1.MetadataService }, { type: i2.MatDialog }]; }, { layer: [{
+            type: Input
+        }], color: [{
+            type: Input
+        }] }); })();
+export class MetadataAbstractComponent {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    static ɵfac = function MetadataAbstractComponent_Factory(t) { return new (t || MetadataAbstractComponent)(i0.ɵɵdirectiveInject(MAT_DIALOG_DATA)); };
+    static ɵ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: [":host{position:relative;display:block}:host .close-button{top:5px;right:5px;padding:7px;line-height:10px;position:absolute!important;min-width:auto}\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>\n<button class=\"close-button\" mat-button mat-dialog-close>X</button>\n<mat-dialog-content *ngIf=\"data.type !== 'arcgisrest'\" class=\"mat-typography\">\n  <h3>{{ data.abstract }}</h3>\n</mat-dialog-content>\n<mat-dialog-content *ngIf=\"data.type === 'arcgisrest'\" class=\"mat-typography\">\n  <h3 [innerHTML]=\"data.abstract\"></h3>\n</mat-dialog-content>\n", styles: [":host{position:relative;display:block}:host .close-button{top:5px;right:5px;padding:7px;line-height:10px;position:absolute!important;min-width:auto}\n"] }]
+    }], function () { return [{ type: undefined, decorators: [{
+                type: Inject,
+                args: [MAT_DIALOG_DATA]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/metadata/metadata.module.mjs

@@ -0,0 +1,47 @@
+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: []
+        };
+    }
+    static ɵfac = function IgoMetadataModule_Factory(t) { return new (t || IgoMetadataModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoMetadataModule });
+    static ɵ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/esm2022/lib/metadata/shared/index.mjs

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

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

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

package/esm2022/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');
+        }
+    }
+    static ɵfac = function MetadataService_Factory(t) { return new (t || MetadataService)(); };
+    static ɵ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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0YWRhdGEuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL21ldGFkYXRhL3NoYXJlZC9tZXRhZGF0YS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTzNDLE1BQU0sT0FBTyxlQUFlO0lBQzFCLGdCQUFlLENBQUM7SUFFaEIsSUFBSSxDQUFDLFFBQXlCO1FBQzVCLElBQUksUUFBUSxDQUFDLE1BQU0sRUFBRTtZQUNuQixNQUFNLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLEVBQUUsUUFBUSxDQUFDLENBQUM7U0FDckM7SUFDSCxDQUFDO3lFQVBVLGVBQWU7Z0VBQWYsZUFBZSxXQUFmLGVBQWUsbUJBRmQsTUFBTTs7dUZBRVAsZUFBZTtjQUgzQixVQUFVO2VBQUM7Z0JBQ1YsVUFBVSxFQUFFLE1BQU07YUFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IE1ldGFkYXRhT3B0aW9ucyB9IGZyb20gJy4vbWV0YWRhdGEuaW50ZXJmYWNlJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgTWV0YWRhdGFTZXJ2aWNlIHtcbiAgY29uc3RydWN0b3IoKSB7fVxuXG4gIG9wZW4obWV0YWRhdGE6IE1ldGFkYXRhT3B0aW9ucykge1xuICAgIGlmIChtZXRhZGF0YS5leHRlcm4pIHtcbiAgICAgIHdpbmRvdy5vcGVuKG1ldGFkYXRhLnVybCwgJ19ibGFuaycpO1xuICAgIH1cbiAgfVxufVxuIl19

package/esm2022/lib/offline/geoDB/configFileToGeoDB.service.mjs

@@ -0,0 +1,128 @@
+import { Injectable } from '@angular/core';
+import { MessageService } from '@igo2/core';
+import { HttpClient } from '@angular/common/http';
+import { catchError, concatMap } from 'rxjs/operators';
+import { GeoDBService } from './geoDB.service';
+import { of, zip } from 'rxjs';
+import { default as JSZip } from 'jszip';
+import { InsertSourceInsertDBEnum } from './geoDB.enums';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./geoDB.service";
+import * as i3 from "@igo2/core";
+export class ConfigFileToGeoDBService {
+    http;
+    geoDBService;
+    messageService;
+    constructor(http, geoDBService, messageService) {
+        this.http = http;
+        this.geoDBService = geoDBService;
+        this.messageService = messageService;
+    }
+    load(url) {
+        let downloadMessage;
+        this.http
+            .get(url)
+            .pipe(catchError((error) => {
+            console.log(`GeoData file ${url} could not be read`);
+            error.error.caught = true;
+            throw error;
+        }), concatMap((datasToIDB) => {
+            const datas$ = [];
+            let firstDownload = true;
+            if (datasToIDB?.geoDatas) {
+                const currentDate = new Date();
+                datasToIDB?.geoDatas.map((geoData) => {
+                    if (typeof geoData.triggerDate === 'string') {
+                        geoData.triggerDate = new Date(Date.parse(geoData.triggerDate));
+                    }
+                    if (currentDate >= geoData.triggerDate) {
+                        if (geoData.action === 'update') {
+                            const insertEvent = `${geoData.source || InsertSourceInsertDBEnum.System} (${geoData.triggerDate})`;
+                            geoData.urls.map((url) => {
+                                datas$.push(this.geoDBService.getByID(url).pipe(concatMap((res) => {
+                                    if (res?.insertEvent !== insertEvent) {
+                                        if (firstDownload) {
+                                            downloadMessage = this.messageService.info('igo.geo.indexedDb.data-download-start', undefined, {
+                                                disableTimeOut: true,
+                                                progressBar: false,
+                                                closeButton: true,
+                                                tapToDismiss: false
+                                            });
+                                            firstDownload = false;
+                                        }
+                                        let responseType = 'json';
+                                        const isZip = this.isZip(url);
+                                        if (isZip) {
+                                            responseType = 'arraybuffer';
+                                        }
+                                        return this.http.get(url, { responseType }).pipe(concatMap((r) => {
+                                            if (isZip) {
+                                                const observables$ = [
+                                                    this.geoDBService.update(url, url, {}, InsertSourceInsertDBEnum.System, insertEvent)
+                                                ];
+                                                JSZip.loadAsync(r).then((zipped) => {
+                                                    zipped.forEach((relativePath) => {
+                                                        if (relativePath
+                                                            .toLocaleLowerCase()
+                                                            .endsWith('.geojson')) {
+                                                            zipped
+                                                                .file(relativePath)
+                                                                .async('text')
+                                                                .then((r) => {
+                                                                const geojson = JSON.parse(r);
+                                                                const subUrl = geoData.zippedBaseUrl || '';
+                                                                const zippedUrl = subUrl +
+                                                                    (subUrl.endsWith('/')
+                                                                        ? ''
+                                                                        : '/') +
+                                                                    relativePath;
+                                                                observables$.push(this.geoDBService.update(zippedUrl, url, geojson, InsertSourceInsertDBEnum.System, insertEvent));
+                                                            });
+                                                        }
+                                                    });
+                                                });
+                                                return zip(observables$);
+                                            }
+                                            return this.geoDBService.update(url, url, r, InsertSourceInsertDBEnum.System, insertEvent);
+                                        }));
+                                    }
+                                    else {
+                                        return of(false);
+                                    }
+                                })));
+                            });
+                        }
+                        else if (geoData.action === 'delete') {
+                            geoData.urls.map((url) => {
+                                datas$.push(this.geoDBService.deleteByKey(url));
+                            });
+                        }
+                    }
+                });
+            }
+            return zip(...datas$);
+        }))
+            .subscribe(() => {
+            if (downloadMessage) {
+                setTimeout(() => {
+                    this.messageService.remove(downloadMessage.toastId);
+                    this.messageService.success('igo.geo.indexedDb.data-download-completed', undefined, { timeOut: 40000 });
+                }, 2500);
+            }
+        });
+    }
+    isZip(value) {
+        const regex = /(zip)$/;
+        return typeof value === 'string' && regex.test(value.toLowerCase());
+    }
+    static ɵfac = function ConfigFileToGeoDBService_Factory(t) { return new (t || ConfigFileToGeoDBService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.GeoDBService), i0.ɵɵinject(i3.MessageService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ConfigFileToGeoDBService, factory: ConfigFileToGeoDBService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ConfigFileToGeoDBService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.GeoDBService }, { type: i3.MessageService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configFileToGeoDB.service.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/offline/geoDB/configFileToGeoDB.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { MessageService } from '@igo2/core';\nimport { HttpClient } from '@angular/common/http';\nimport { catchError, concatMap } from 'rxjs/operators';\nimport { GeoDBService } from './geoDB.service';\nimport { of, zip } from 'rxjs';\nimport { DatasToIDB, GeoDBData } from './geoDB.interface';\nimport { default as JSZip } from 'jszip';\nimport { InsertSourceInsertDBEnum } from './geoDB.enums';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ConfigFileToGeoDBService {\n  constructor(\n    private http: HttpClient,\n    private geoDBService: GeoDBService,\n    private messageService: MessageService\n  ) {}\n\n  load(url: string) {\n    let downloadMessage;\n    this.http\n      .get(url)\n      .pipe(\n        catchError((error: any): any => {\n          console.log(`GeoData file ${url} could not be read`);\n          error.error.caught = true;\n          throw error;\n        }),\n        concatMap((datasToIDB: DatasToIDB) => {\n          const datas$ = [];\n          let firstDownload = true;\n          if (datasToIDB?.geoDatas) {\n            const currentDate = new Date();\n            datasToIDB?.geoDatas.map((geoData) => {\n              if (typeof geoData.triggerDate === 'string') {\n                geoData.triggerDate = new Date(Date.parse(geoData.triggerDate));\n              }\n              if (currentDate >= geoData.triggerDate) {\n                if (geoData.action === 'update') {\n                  const insertEvent = `${\n                    geoData.source || InsertSourceInsertDBEnum.System\n                  } (${geoData.triggerDate})`;\n                  geoData.urls.map((url) => {\n                    datas$.push(\n                      this.geoDBService.getByID(url).pipe(\n                        concatMap((res: GeoDBData) => {\n                          if (res?.insertEvent !== insertEvent) {\n                            if (firstDownload) {\n                              downloadMessage = this.messageService.info(\n                                'igo.geo.indexedDb.data-download-start',\n                                undefined,\n                                {\n                                  disableTimeOut: true,\n                                  progressBar: false,\n                                  closeButton: true,\n                                  tapToDismiss: false\n                                }\n                              );\n                              firstDownload = false;\n                            }\n                            let responseType: any = 'json';\n                            const isZip = this.isZip(url);\n                            if (isZip) {\n                              responseType = 'arraybuffer';\n                            }\n                            return this.http.get(url, { responseType }).pipe(\n                              concatMap((r) => {\n                                if (isZip) {\n                                  const observables$ = [\n                                    this.geoDBService.update(\n                                      url,\n                                      url,\n                                      {},\n                                      InsertSourceInsertDBEnum.System,\n                                      insertEvent\n                                    )\n                                  ];\n                                  JSZip.loadAsync(r).then((zipped) => {\n                                    zipped.forEach((relativePath) => {\n                                      if (\n                                        relativePath\n                                          .toLocaleLowerCase()\n                                          .endsWith('.geojson')\n                                      ) {\n                                        zipped\n                                          .file(relativePath)\n                                          .async('text')\n                                          .then((r) => {\n                                            const geojson = JSON.parse(r);\n                                            const subUrl =\n                                              geoData.zippedBaseUrl || '';\n                                            const zippedUrl =\n                                              subUrl +\n                                              (subUrl.endsWith('/')\n                                                ? ''\n                                                : '/') +\n                                              relativePath;\n                                            observables$.push(\n                                              this.geoDBService.update(\n                                                zippedUrl,\n                                                url,\n                                                geojson,\n                                                InsertSourceInsertDBEnum.System,\n                                                insertEvent\n                                              )\n                                            );\n                                          });\n                                      }\n                                    });\n                                  });\n                                  return zip(observables$);\n                                }\n                                return this.geoDBService.update(\n                                  url,\n                                  url,\n                                  r,\n                                  InsertSourceInsertDBEnum.System,\n                                  insertEvent\n                                );\n                              })\n                            );\n                          } else {\n                            return of(false);\n                          }\n                        })\n                      )\n                    );\n                  });\n                } else if (geoData.action === 'delete') {\n                  geoData.urls.map((url) => {\n                    datas$.push(this.geoDBService.deleteByKey(url));\n                  });\n                }\n              }\n            });\n          }\n          return zip(...datas$);\n        })\n      )\n      .subscribe(() => {\n        if (downloadMessage) {\n          setTimeout(() => {\n            this.messageService.remove((downloadMessage as any).toastId);\n            this.messageService.success(\n              'igo.geo.indexedDb.data-download-completed',\n              undefined,\n              { timeOut: 40000 }\n            );\n          }, 2500);\n        }\n      });\n  }\n\n  private isZip(value) {\n    const regex = /(zip)$/;\n    return typeof value === 'string' && regex.test(value.toLowerCase());\n  }\n}\n"]}

package/esm2022/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VvREIuZW51bXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9vZmZsaW5lL2dlb0RCL2dlb0RCLmVudW1zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLHdCQUdYO0FBSEQsV0FBWSx3QkFBd0I7SUFDbEMsNkNBQWlCLENBQUE7SUFDakIseUNBQWEsQ0FBQTtBQUNmLENBQUMsRUFIVyx3QkFBd0IsS0FBeEIsd0JBQXdCLFFBR25DIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gSW5zZXJ0U291cmNlSW5zZXJ0REJFbnVtIHtcbiAgU3lzdGVtID0gJ3N5c3RlbScsXG4gIFVzZXIgPSAndXNlcidcbn1cbiJdfQ==

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

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

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

@@ -0,0 +1,175 @@
+import { Injectable } from '@angular/core';
+import { DBMode, NgxIndexedDBService } from 'ngx-indexed-db';
+import { of, Subject } from 'rxjs';
+import { concatMap, first, map, take } from 'rxjs/operators';
+import { CompressionService } from '@igo2/core';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-indexed-db";
+import * as i2 from "@igo2/core";
+export class GeoDBService {
+    ngxIndexedDBService;
+    compression;
+    dbName = 'geoData';
+    collisionsMap = new Map();
+    _newData = 0;
+    constructor(ngxIndexedDBService, compression) {
+        this.ngxIndexedDBService = ngxIndexedDBService;
+        this.compression = compression;
+    }
+    /**
+     * Only blob can 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._newData++;
+                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);
+            }
+        }));
+    }
+    getByID(url) {
+        return this.ngxIndexedDBService.getByID(this.dbName, url);
+    }
+    deleteByKey(url) {
+        return this.ngxIndexedDBService.deleteByKey(this.dbName, url);
+    }
+    getRegionCountByID(id) {
+        const subject = new Subject();
+        const dbRequest = this.getRegionByID(id).subscribe((datas) => {
+            subject.next(datas.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((datas) => {
+            datas.forEach((data) => {
+                this.ngxIndexedDBService.deleteByKey(this.dbName, data.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._newData = 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 newData() {
+        return this._newData;
+    }
+    static ɵfac = function GeoDBService_Factory(t) { return new (t || GeoDBService)(i0.ɵɵinject(i1.NgxIndexedDBService), i0.ɵɵinject(i2.CompressionService)); };
+    static ɵ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';\nimport { DBMode, NgxIndexedDBService } from 'ngx-indexed-db';\nimport { Observable, of, Subject } from 'rxjs';\nimport { concatMap, first, map, take } from 'rxjs/operators';\nimport { CompressionService } from '@igo2/core';\nimport { GeoDBData } from './geoDB.interface';\nimport { InsertSourceInsertDBEnum } from './geoDB.enums';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class GeoDBService {\n  readonly dbName: string = 'geoData';\n  public collisionsMap: Map<number, string[]> = new Map();\n  public _newData: number = 0;\n\n  constructor(\n    private ngxIndexedDBService: NgxIndexedDBService,\n    private compression: CompressionService\n  ) {}\n\n  /**\n   * Only blob can be compressed\n   * @param url\n   * @param regionID\n   * @param object object to handle\n   * @param insertSource type of event user or system\n   * @param insertEvent Name of the event where the insert has been triggered\n   * @returns\n   */\n  update(\n    url: string,\n    regionID: any,\n    object: any,\n    insertSource: InsertSourceInsertDBEnum,\n    insertEvent: string\n  ): Observable<any> {\n    if (!object) {\n      return;\n    }\n    let compress = false;\n\n    const subject: Subject<GeoDBData> = new Subject();\n    let object$: Observable<any> = of(object);\n    if (object instanceof Blob) {\n      object$ = this.compression.compressBlob(object);\n      compress = true;\n    }\n    let geoDBData: GeoDBData;\n    object$\n      .pipe(\n        first(),\n        concatMap((object) => {\n          geoDBData = {\n            url,\n            regionID,\n            object: object,\n            compressed: compress,\n            insertSource,\n            insertEvent\n          };\n          return this.ngxIndexedDBService.getByID(this.dbName, url);\n        }),\n        concatMap((dbObject: GeoDBData) => {\n          if (!dbObject) {\n            this._newData++;\n            return this.ngxIndexedDBService.add(this.dbName, geoDBData);\n          } else {\n            const currentRegionID = dbObject.regionID;\n            if (currentRegionID !== regionID) {\n              const collisions = this.collisionsMap.get(currentRegionID);\n              if (collisions !== undefined) {\n                collisions.push(dbObject.url);\n                this.collisionsMap.set(currentRegionID, collisions);\n              } else {\n                this.collisionsMap.set(currentRegionID, [dbObject.url]);\n              }\n            }\n            return this.customUpdate(geoDBData);\n          }\n        })\n      )\n      .subscribe((response) => {\n        subject.next(response);\n        subject.complete();\n      });\n    return subject;\n  }\n\n  private customUpdate(geoDBData: GeoDBData): Observable<GeoDBData> {\n    const subject: Subject<GeoDBData> = new Subject();\n    const deleteRequest = this.ngxIndexedDBService.deleteByKey(\n      this.dbName,\n      geoDBData.url\n    );\n    deleteRequest\n      .pipe(\n        concatMap((isDeleted) =>\n          isDeleted\n            ? this.ngxIndexedDBService.add(this.dbName, geoDBData)\n            : of(undefined)\n        )\n      )\n      .subscribe((object) => {\n        if (object) {\n          subject.next(object);\n        }\n        subject.complete();\n      });\n    return subject;\n  }\n\n  get(url: string): Observable<any> {\n    return this.ngxIndexedDBService.getByID(this.dbName, url).pipe(\n      map((data: GeoDBData) => {\n        if (data) {\n          const object = data.object;\n          if (!data.compressed) {\n            return object;\n          }\n          return this.compression.decompressBlob(object);\n        }\n      })\n    );\n  }\n\n  getByID(url: string): Observable<any> {\n    return this.ngxIndexedDBService.getByID(this.dbName, url);\n  }\n\n  deleteByKey(url: string): Observable<any> {\n    return this.ngxIndexedDBService.deleteByKey(this.dbName, url);\n  }\n\n  getRegionCountByID(id: number): Observable<number> {\n    const subject: Subject<number> = new Subject();\n    const dbRequest = this.getRegionByID(id).subscribe((datas) => {\n      subject.next(datas.length);\n      subject.complete();\n    });\n    return subject;\n  }\n\n  getRegionByID(id: number): Observable<any[]> {\n    if (!id) {\n      return;\n    }\n\n    const IDBKey: IDBKeyRange = IDBKeyRange.only(id);\n    const dbRequest = this.ngxIndexedDBService.getAllByIndex(\n      this.dbName,\n      'regionID',\n      IDBKey\n    );\n    return dbRequest;\n  }\n\n  deleteByRegionID(id: number): Observable<any> {\n    if (!id) {\n      return;\n    }\n\n    const IDBKey: IDBKeyRange = IDBKeyRange.only(id);\n    const dbRequest = this.ngxIndexedDBService.getAllByIndex(\n      this.dbName,\n      'regionID',\n      IDBKey\n    );\n    dbRequest.subscribe((datas: GeoDBData[]) => {\n      datas.forEach((data) => {\n        this.ngxIndexedDBService.deleteByKey(this.dbName, data.url);\n      });\n    });\n    return dbRequest;\n  }\n\n  openCursor(\n    keyRange: IDBKeyRange = IDBKeyRange.lowerBound(0),\n    mode: DBMode = DBMode.readonly\n  ) {\n    const request = this.ngxIndexedDBService.openCursorByIndex(\n      this.dbName,\n      'regionID',\n      keyRange,\n      mode\n    );\n    return request;\n  }\n\n  resetCounters() {\n    this.resetCollisionsMap();\n    this._newData = 0;\n  }\n\n  resetCollisionsMap() {\n    this.collisionsMap = new Map();\n  }\n\n  revertCollisions() {\n    for (const [regionID, collisions] of this.collisionsMap) {\n      for (const url of collisions) {\n        this.ngxIndexedDBService\n          .getByKey(this.dbName, url)\n          .pipe(take(1))\n          .subscribe((dbObject: GeoDBData) => {\n            const updatedObject = dbObject;\n            updatedObject.regionID = regionID;\n            this.customUpdate(dbObject);\n          });\n      }\n    }\n  }\n\n  get newData(): number {\n    return this._newData;\n  }\n}\n"]}

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

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

package/esm2022/lib/offline/index.mjs

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

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

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