@igo2/geo 21.0.0-next.2 → 21.0.0-next.21

package/fesm2022/igo2-geo-offline.mjs

@@ -0,0 +1,710 @@
+import { Compression, ObjectUtils } from '@igo2/utils';
+import { from, of, switchMap, first, concatMap, map, mergeMap, zip, forkJoin, defer, EMPTY, fromEvent, merge, combineLatest } from 'rxjs';
+import { openDB } from 'idb';
+import { HttpClient } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { inject, Injectable, Injector, makeEnvironmentProviders, provideAppInitializer } from '@angular/core';
+import { MessageService } from '@igo2/core/message';
+import JSZip from 'jszip';
+import { catchError, concatMap as concatMap$1, first as first$1, delay, tap, switchMap as switchMap$1, debounceTime, map as map$1 } from 'rxjs/operators';
+import { NetworkService } from '@igo2/core/network';
+import { isOlFlatStyleLike, LayerService, LAYER_PERSISTENCE, OFFLINE_LAYER_RESTORE, VECTOR_LAYER_EXTENSIONS } from '@igo2/geo';
+import * as olformat from 'ol/format';
+import { ConfigService } from '@igo2/core/config';
+
+var InsertSourceInsertDBEnum;
+(function (InsertSourceInsertDBEnum) {
+    InsertSourceInsertDBEnum["System"] = "system";
+    InsertSourceInsertDBEnum["User"] = "user";
+})(InsertSourceInsertDBEnum || (InsertSourceInsertDBEnum = {}));
+
+function createIndexedDb() {
+    return openDB('igo2DB', undefined, {
+        upgrade(db) {
+            const geoDataStore = db.createObjectStore('geoData', {
+                keyPath: 'url',
+                autoIncrement: false
+            });
+            geoDataStore.createIndex('regionID-idx', 'regionID', {
+                unique: false
+            });
+            db.createObjectStore('layerData', {
+                keyPath: 'layerId',
+                autoIncrement: false
+            });
+        }
+    });
+}
+
+class GeoDB {
+    db$;
+    compression = new Compression();
+    collisionsMap = new Map();
+    _newData = 0;
+    revertObservablesSubscription;
+    constructor() {
+        this.db$ = from(createIndexedDb());
+    }
+    /**
+     * 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) {
+        const object$ = (object instanceof Blob
+            ? this.compression.compressBlob(object)
+            : of(object));
+        const compress = object instanceof Blob ? true : false;
+        let geoDBData;
+        const a = this.db$.pipe(switchMap((db) => {
+            return object$.pipe(first(), switchMap((object) => {
+                geoDBData = {
+                    url,
+                    regionID,
+                    object: object,
+                    compressed: compress,
+                    insertSource,
+                    insertEvent
+                };
+                return this.getGeoDBData(url);
+            }), concatMap((res) => {
+                const dbObject = res;
+                if (!dbObject) {
+                    this._newData++;
+                    return from(db.add('geoData', geoDBData)).pipe(map(() => 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);
+                }
+            }));
+        }));
+        return a;
+    }
+    customUpdate(geoDBData) {
+        const b = this.delete(geoDBData.url).pipe(mergeMap(() => this.add(geoDBData)));
+        return b;
+    }
+    add(geoDBData) {
+        return this.db$.pipe(switchMap((db) => from(db?.add('geoData', geoDBData)).pipe(map(() => geoDBData))));
+    }
+    put(geoDBData) {
+        return this.db$.pipe(switchMap((db) => from(db?.put('geoData', geoDBData)).pipe(map(() => geoDBData))));
+    }
+    getGeoDBData(url) {
+        return this.db$.pipe(switchMap((db) => from(db?.get('geoData', url))));
+    }
+    get(url) {
+        return this.getGeoDBData(url).pipe(mergeMap((data) => {
+            const rObj = !data?.compressed
+                ? data?.object
+                : this.compression.decompressBlob(data?.object);
+            return of(rObj);
+        }));
+    }
+    delete(key) {
+        return this.db$.pipe(switchMap((db) => from(db?.delete('geoData', key))), map(() => {
+            {
+                return { key };
+            }
+        }));
+    }
+    getRegionCountByID(id) {
+        return this.getRegionByID(id).pipe(switchMap((datas) => {
+            return of(datas.length);
+        }));
+    }
+    getRegionByID(id) {
+        if (!id) {
+            return of([]);
+        }
+        const IDBKey = IDBKeyRange.only(id);
+        return this.db$.pipe(switchMap((db) => from(db?.getAllFromIndex('geoData', 'regionID-idx', IDBKey))));
+    }
+    deleteByRegionID(id) {
+        if (!id) {
+            return of([]);
+        }
+        return this.db$.pipe(switchMap((db) => {
+            const tx = db.transaction('geoData', 'readwrite');
+            return of(tx);
+        }), mergeMap((tx) => this.getRegionByID(id).pipe(concatMap((datas) => {
+            const promises = datas.map((data) => tx.store.delete(data.url));
+            promises.push(tx.done);
+            return from(Promise.all(promises));
+        }))));
+    }
+    resetCounters() {
+        this.resetCollisionsMap();
+        this._newData = 0;
+    }
+    resetCollisionsMap() {
+        this.collisionsMap = new Map();
+    }
+    revertCollisions() {
+        if (this.revertObservablesSubscription) {
+            this.revertObservablesSubscription.unsubscribe();
+        }
+        const revertObservables = [];
+        for (const [regionID, collisions] of this.collisionsMap) {
+            for (const url of collisions) {
+                revertObservables.push(this.getGeoDBData(url).pipe(first(), concatMap((dbObject) => {
+                    const updatedObject = dbObject;
+                    updatedObject.regionID = regionID;
+                    return this.customUpdate(updatedObject);
+                })));
+            }
+        }
+        this.revertObservablesSubscription = zip(...revertObservables).subscribe();
+    }
+    get newData() {
+        return this._newData;
+    }
+}
+
+/** Delay before dismissing the "download completed" toast, so it stays legible for a moment. */
+const DOWNLOAD_COMPLETED_DELAY_MS = 2500;
+const TOAST_TIMEOUT_MS = 40000;
+class GeoDataSyncService {
+    http = inject(HttpClient);
+    messageService = inject(MessageService);
+    load(urlFile) {
+        const geoDB = new GeoDB();
+        const downloadState = {};
+        this.http
+            .get(urlFile)
+            .pipe(catchError((error) => this.handleConfigFileError(urlFile, error)), concatMap$1((datasToIDB) => this.processGeoDatas(geoDB, datasToIDB?.geoDatas ?? [], downloadState)))
+            .subscribe(() => this.notifyDownloadCompleted(downloadState));
+    }
+    handleConfigFileError(urlFile, error) {
+        this.messageService.error(`GeoData file ${urlFile} could not be read`);
+        error.error.caught = true;
+        throw error;
+    }
+    processGeoDatas(geoDB, geoDatas, downloadState) {
+        const currentDate = new Date();
+        const operations = [];
+        for (const geoData of geoDatas) {
+            if (typeof geoData.triggerDate === 'string') {
+                geoData.triggerDate = new Date(Date.parse(geoData.triggerDate));
+            }
+            if (currentDate < geoData.triggerDate) {
+                continue;
+            }
+            if (geoData.action === 'update') {
+                operations.push(...this.updateGeoData(geoDB, geoData, downloadState));
+            }
+            else if (geoData.action === 'delete') {
+                operations.push(...geoData.urls.map((url) => geoDB.delete(url)));
+            }
+        }
+        return forkJoin(operations);
+    }
+    updateGeoData(geoDB, geoData, downloadState) {
+        const insertEvent = `${geoData.source || InsertSourceInsertDBEnum.System} (${geoData.triggerDate})`;
+        return geoData.urls.map((url) => geoDB
+            .getGeoDBData(url)
+            .pipe(concatMap$1((existing) => existing?.insertEvent === insertEvent
+            ? of(false)
+            : this.downloadAndStore(geoDB, url, geoData, insertEvent, downloadState))));
+    }
+    downloadAndStore(geoDB, url, geoData, insertEvent, downloadState) {
+        this.showDownloadStartMessage(downloadState);
+        const isZip = this.isZip(url);
+        const download$ = isZip
+            ? this.http.get(url, { responseType: 'arraybuffer' })
+            : this.http.get(url, { responseType: 'json' });
+        return download$.pipe(catchError((error) => this.handleDownloadError(downloadState, error)), concatMap$1((response) => isZip
+            ? this.storeZippedGeoData(geoDB, response, url, geoData, insertEvent)
+            : geoDB.update(url, url, response, InsertSourceInsertDBEnum.System, insertEvent)));
+    }
+    handleDownloadError(downloadState, error) {
+        if (downloadState.toast) {
+            this.messageService.remove(downloadState.toast.toastId);
+        }
+        this.messageService.error('igo.geo.indexedDb.data-download-failed', undefined, { timeOut: TOAST_TIMEOUT_MS });
+        error.error.caught = true;
+        throw error;
+    }
+    storeZippedGeoData(geoDB, archive, url, geoData, insertEvent) {
+        return from(this.extractZipGeojsonEntries(archive, geoData.zippedBaseUrl)).pipe(concatMap$1((entries) => forkJoin([
+            // the archive itself is tracked so future loads can detect it was already processed
+            geoDB.update(url, url, {}, InsertSourceInsertDBEnum.System, insertEvent),
+            ...entries.map(({ zippedUrl, geojson }) => geoDB.update(zippedUrl, url, geojson, InsertSourceInsertDBEnum.System, insertEvent))
+        ])));
+    }
+    async extractZipGeojsonEntries(archive, zippedBaseUrl = '') {
+        const zipped = await JSZip.loadAsync(archive);
+        const baseUrl = zippedBaseUrl.endsWith('/')
+            ? zippedBaseUrl
+            : `${zippedBaseUrl}/`;
+        const geojsonPaths = Object.keys(zipped.files).filter((relativePath) => relativePath.toLowerCase().endsWith('.geojson'));
+        return Promise.all(geojsonPaths.map(async (relativePath) => ({
+            zippedUrl: `${baseUrl}${relativePath}`,
+            geojson: JSON.parse(await zipped.file(relativePath).async('text'))
+        })));
+    }
+    showDownloadStartMessage(downloadState) {
+        if (downloadState.toast) {
+            return;
+        }
+        downloadState.toast = this.messageService.info('igo.geo.indexedDb.data-download-start', undefined, {
+            disableTimeOut: true,
+            progressBar: false,
+            closeButton: true,
+            tapToDismiss: false
+        });
+    }
+    notifyDownloadCompleted(downloadState) {
+        if (!downloadState.toast) {
+            return;
+        }
+        const toast = downloadState.toast;
+        setTimeout(() => {
+            this.messageService.remove(toast.toastId);
+            this.messageService.success('igo.geo.indexedDb.data-download-completed', undefined, { timeOut: TOAST_TIMEOUT_MS });
+        }, DOWNLOAD_COMPLETED_DELAY_MS);
+    }
+    isZip(value) {
+        const regex = /(zip)$/;
+        return typeof value === 'string' && regex.test(value.toLowerCase());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: GeoDataSyncService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: GeoDataSyncService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: GeoDataSyncService, decorators: [{
+            type: Injectable
+        }] });
+
+class LayerDB {
+    dbPromise;
+    constructor() {
+        this.dbPromise = createIndexedDb();
+    }
+    /**
+     * This method allow to update the stored layer into the indexeddb (layerData)
+     * @param layerDBData
+     * @returns
+     */
+    update(layerDBData) {
+        return from(this.updateAsync(layerDBData));
+    }
+    async updateAsync(layerDBData) {
+        const db = await this.dbPromise;
+        const existing = await db.get('layerData', layerDBData.layerId);
+        if (existing) {
+            await db.delete('layerData', layerDBData.layerId);
+        }
+        await db.add('layerData', layerDBData);
+        return layerDBData;
+    }
+    add(layerDBData) {
+        return from(this.addAsync(layerDBData));
+    }
+    async addAsync(layerDBData) {
+        const db = await this.dbPromise;
+        await db.add('layerData', layerDBData);
+        return layerDBData;
+    }
+    /**
+     * This method retrieve an idb layer definition
+     * @param layerId
+     * @returns
+     */
+    getByID(layerId) {
+        return from(this.getByIDAsync(layerId));
+    }
+    async getByIDAsync(layerId) {
+        const db = await this.dbPromise;
+        return db.get('layerData', layerId.toString());
+    }
+    /**
+     * This method delete an idb layer definition
+     * @param key
+     * @returns
+     */
+    delete(key) {
+        return from(this.deleteAsync(key));
+    }
+    async deleteAsync(key) {
+        const db = await this.dbPromise;
+        await db.delete('layerData', key);
+        return { key };
+    }
+    /**
+     * This method retrive all idb layer definition
+     * @param layerId
+     * @returns
+     */
+    getAll() {
+        return from(this.getAllAsync());
+    }
+    async getAllAsync() {
+        const db = await this.dbPromise;
+        return db.getAll('layerData');
+    }
+}
+
+class GeoNetworkService {
+    http = inject(HttpClient);
+    networkService = inject(NetworkService);
+    networkOnline = true;
+    constructor() {
+        this.networkService.currentState().subscribe((state) => {
+            this.networkOnline = state.connection;
+        });
+    }
+    get(url, simpleGetOptions) {
+        if (window.navigator.onLine && this.networkOnline) {
+            return this.getOnline(url, simpleGetOptions);
+        }
+        return this.getOffline(url);
+    }
+    getOnline(url, simpleGetOptions) {
+        let request;
+        switch (simpleGetOptions.responseType) {
+            case 'arraybuffer':
+                request = this.http.get(url, {
+                    responseType: 'arraybuffer',
+                    withCredentials: simpleGetOptions.withCredentials
+                });
+                break;
+            case 'text':
+                request = this.http.get(url, {
+                    responseType: 'text',
+                    withCredentials: simpleGetOptions.withCredentials
+                });
+                break;
+            case 'json':
+                request = this.http.get(url, {
+                    responseType: 'json',
+                    withCredentials: simpleGetOptions.withCredentials
+                });
+                break;
+            default:
+                request = this.http.get(url, {
+                    responseType: 'blob',
+                    withCredentials: simpleGetOptions.withCredentials
+                });
+                break;
+        }
+        return request;
+    }
+    getOffline(url) {
+        const geoDB = new GeoDB();
+        return geoDB?.get(url);
+    }
+    isOnline() {
+        return this.networkOnline && window.navigator.onLine;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: GeoNetworkService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: GeoNetworkService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: GeoNetworkService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class IndexedDbLayerPersistenceService {
+    geoDB = inject(GeoDB);
+    layerDB = inject(LayerDB);
+    isPersistent(layer) {
+        if (layer.type !== 'vector') {
+            return false;
+        }
+        const options = layer.options;
+        return options.offline?.enabled === true;
+    }
+    removePersistedData(layer) {
+        if (!this.isPersistent(layer) || layer.id === undefined) {
+            return;
+        }
+        const options = layer.options;
+        const layerId = layer.id.toString();
+        const sourceUrl = options.sourceOptions?.url;
+        const featureStorageKey = typeof sourceUrl === 'string' && sourceUrl.length > 0
+            ? sourceUrl
+            : layerId;
+        forkJoin([
+            this.geoDB.delete(featureStorageKey),
+            this.layerDB.delete(layerId)
+        ]).subscribe();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: IndexedDbLayerPersistenceService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: IndexedDbLayerPersistenceService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: IndexedDbLayerPersistenceService, decorators: [{
+            type: Injectable
+        }] });
+
+class IndexedDbVectorLayerExtensionInstance {
+    context;
+    geoDB;
+    layerDB;
+    geoNetworkService;
+    subscriptions = [];
+    constructor(context, geoDB, layerDB, geoNetworkService) {
+        this.context = context;
+        this.geoDB = geoDB;
+        this.layerDB = layerDB;
+        this.geoNetworkService = geoNetworkService;
+        this.registerPersistence();
+    }
+    interceptLoad(request, next) {
+        if (typeof request.url === 'function') {
+            next(request);
+            return;
+        }
+        const requestUrl = request.url;
+        const storageKey = this.context.options.sourceOptions?.url ||
+            this.context.id?.toString() ||
+            requestUrl;
+        const responseType = this.context.source
+            .getFormat()
+            .getType();
+        const getVectorObs$ = defer(() => this.geoNetworkService.get(requestUrl, { responseType })).pipe(first$1());
+        const idbGetVectorObs$ = this.geoDB.get(storageKey).pipe(catchError(() => of(undefined)), delay(750), concatMap$1((response) => (response ? of(response) : getVectorObs$)), tap((content) => this.handleOnLoad(request, content)), catchError(() => {
+            request.source.removeLoadedExtent(request.extent);
+            request.failure();
+            return EMPTY;
+        }));
+        this.subscriptions.push(idbGetVectorObs$.subscribe());
+    }
+    destroy() {
+        this.subscriptions.forEach((subscription) => subscription.unsubscribe());
+        this.subscriptions = [];
+    }
+    registerPersistence() {
+        const sourceReady$ = fromEvent(this.context.layer, 'sourceready');
+        const featurePersistSubscription = sourceReady$
+            .pipe(tap(() => {
+            if (this.context.source.getFeatures().length > 0) {
+                this.maintainFeaturesInIdb();
+            }
+            this.maintainOptionsInIdb();
+        }), switchMap$1(() => merge(fromEvent(this.context.source, 'featuresloadend'), fromEvent(this.context.source, 'addfeature'), fromEvent(this.context.source, 'changefeature'), fromEvent(this.context.source, 'clear'), fromEvent(this.context.source, 'removefeature'))))
+            .pipe(debounceTime(750))
+            .subscribe(() => this.maintainFeaturesInIdb());
+        const optionPersistSubscription = sourceReady$
+            .pipe(switchMap$1(() => merge(fromEvent(this.context.layer, 'change'), fromEvent(this.context.layer, 'change:visible'), fromEvent(this.context.layer, 'change:opacity'), fromEvent(this.context.layer, 'change:zIndex'))))
+            .pipe(debounceTime(750))
+            .subscribe(() => this.maintainOptionsInIdb());
+        this.subscriptions.push(featurePersistSubscription, optionPersistSubscription);
+    }
+    maintainOptionsInIdb() {
+        if (this.context.id === undefined) {
+            return;
+        }
+        const id = this.context.id;
+        const options = this.context.options;
+        const offline = this.getOfflineState(options);
+        const layerData = ObjectUtils.removeUndefined({
+            layerId: id,
+            detailedContextUri: offline.contextUri,
+            sourceOptions: {
+                id,
+                type: 'vector',
+                queryable: true,
+                url: options.sourceOptions?.url
+            },
+            layerOptions: {
+                workspace: options.workspace,
+                zIndex: this.context.layer.getZIndex() ?? 1000000,
+                id,
+                isIgoInternalLayer: options.isIgoInternalLayer,
+                title: options.title,
+                visible: this.context.layer.getVisible(),
+                opacity: this.context.layer.getOpacity(),
+                style: isOlFlatStyleLike(options.style) ? options.style : undefined,
+                offline: Object.assign({}, options.offline, {
+                    enabled: true,
+                    contextUri: offline.contextUri
+                })
+            },
+            insertEvent: `${options.title}-${id}-${new Date()}`
+        });
+        this.layerDB.update(layerData).pipe(first$1()).subscribe();
+    }
+    maintainFeaturesInIdb() {
+        if (this.context.id === undefined) {
+            return;
+        }
+        const sourceFeatures = this.context.source.getFeatures().map((feature) => {
+            const persistedFeature = feature.clone();
+            persistedFeature.setId(feature.getId());
+            persistedFeature.unset('_featureStore', true);
+            return persistedFeature;
+        });
+        const geojsonObject = JSON.parse(new olformat.GeoJSON().writeFeatures(sourceFeatures, {
+            dataProjection: 'EPSG:4326',
+            featureProjection: this.context.source.getProjection() || 'EPSG:3857'
+        }));
+        this.geoDB
+            .update(this.context.options.sourceOptions?.url || this.context.id.toString(), this.context.id, geojsonObject, InsertSourceInsertDBEnum.User, `${this.context.options.title}-${this.context.id}-${new Date()}`)
+            .pipe(first$1())
+            .subscribe();
+    }
+    handleOnLoad(request, content) {
+        const format = request.source.getFormat();
+        const type = format.getType();
+        let source;
+        switch (type) {
+            case 'xml':
+                source = new DOMParser().parseFromString(content.toString(), 'application/xml');
+                break;
+            case 'json':
+            case 'text':
+            case 'arraybuffer':
+            default:
+                source = content;
+                break;
+        }
+        const readOptions = {
+            extent: request.extent,
+            featureProjection: request.projection
+        };
+        const features = format.readFeatures(source, readOptions);
+        if (features) {
+            request.source.addFeatures(features);
+            request.success(features);
+            return;
+        }
+        request.success([]);
+    }
+    getOfflineState(options) {
+        return {
+            enabled: options.offline?.enabled === true,
+            contextUri: options.offline?.contextUri
+        };
+    }
+}
+class IndexedDbVectorLayerExtension {
+    id = 'indexed-db';
+    priority = 100;
+    geoDB = inject(GeoDB);
+    layerDB = inject(LayerDB);
+    geoNetworkService = inject(GeoNetworkService);
+    supports(options) {
+        return options.offline?.enabled === true;
+    }
+    attach(context) {
+        return new IndexedDbVectorLayerExtensionInstance(context, this.geoDB, this.layerDB, this.geoNetworkService);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: IndexedDbVectorLayerExtension, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: IndexedDbVectorLayerExtension });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: IndexedDbVectorLayerExtension, decorators: [{
+            type: Injectable
+        }] });
+
+const OfflineFeatureKind = ['IndexedDb'];
+
+class OfflineLayerRestoreService {
+    layerDB = inject(LayerDB);
+    injector = inject(Injector);
+    createAsyncLayers(contextUri = '*') {
+        const layerService = this.injector.get(LayerService);
+        return this.layerDB.getAll().pipe(concatMap$1((persistedLayers) => {
+            const filteredPersistedLayers = contextUri === '*'
+                ? persistedLayers
+                : persistedLayers.filter((layer) => layer.detailedContextUri === contextUri);
+            if (!filteredPersistedLayers.length) {
+                return of([]);
+            }
+            const layerOptions = filteredPersistedLayers.map((persistedLayer) => ({
+                ...persistedLayer.layerOptions,
+                offline: {
+                    enabled: true,
+                    contextUri: persistedLayer.detailedContextUri
+                },
+                sourceOptions: {
+                    ...persistedLayer.sourceOptions,
+                    url: persistedLayer.sourceOptions.url ?? persistedLayer.layerId
+                }
+            }));
+            return combineLatest(layerOptions.map((options) => layerService.createAsyncLayer(options))).pipe(map$1((layers) => layers.filter(Boolean)));
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: OfflineLayerRestoreService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: OfflineLayerRestoreService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.19", ngImport: i0, type: OfflineLayerRestoreService, decorators: [{
+            type: Injectable
+        }] });
+
+function provideOffline(...features) {
+    const providers = [];
+    for (const feature of features) {
+        providers.push(...feature.providers);
+    }
+    return makeEnvironmentProviders(providers);
+}
+function withIndexedDb() {
+    return {
+        kind: 'IndexedDb',
+        providers: [
+            provideAppInitializer(indexedDbInitializerFactory),
+            provideAppInitializer(configFileToGeoDBInitializerFactory),
+            GeoDB,
+            LayerDB,
+            GeoNetworkService,
+            GeoDataSyncService,
+            IndexedDbLayerPersistenceService,
+            {
+                provide: LAYER_PERSISTENCE,
+                useExisting: IndexedDbLayerPersistenceService
+            },
+            OfflineLayerRestoreService,
+            {
+                provide: OFFLINE_LAYER_RESTORE,
+                useExisting: OfflineLayerRestoreService
+            },
+            IndexedDbVectorLayerExtension,
+            {
+                provide: VECTOR_LAYER_EXTENSIONS,
+                useExisting: IndexedDbVectorLayerExtension,
+                multi: true
+            }
+        ]
+    };
+}
+function indexedDbInitializerFactory() {
+    inject(GeoDB);
+    inject(LayerDB);
+    return createIndexedDb();
+}
+async function configFileToGeoDBInitializerFactory() {
+    const configService = inject(ConfigService);
+    const configFileToGeoDBService = inject(GeoDataSyncService);
+    await new Promise((resolve) => {
+        configService.isLoaded$.subscribe((loaded) => {
+            if (loaded) {
+                resolve();
+            }
+        });
+    });
+    const url = configService.getConfig('importExport.configFileToGeoDBService');
+    if (url) {
+        configFileToGeoDBService.load(url);
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { GeoDB, GeoDataSyncService, GeoNetworkService, IndexedDbLayerPersistenceService, IndexedDbVectorLayerExtension, InsertSourceInsertDBEnum, LayerDB, OfflineFeatureKind, createIndexedDb, provideOffline, withIndexedDb };
+//# sourceMappingURL=igo2-geo-offline.mjs.map