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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@igo2/geo",
-  "version": "21.0.0-next.20",
+  "version": "21.0.0-next.21",
   "description": "IGO Library",
   "author": "IGO Community",
   "keywords": [
@@ -22,6 +22,10 @@
       "types": "./types/igo2-geo.d.ts",
       "default": "./fesm2022/igo2-geo.mjs"
     },
+    "./offline": {
+      "types": "./types/igo2-geo-offline.d.ts",
+      "default": "./fesm2022/igo2-geo-offline.mjs"
+    },
     "./style": {
       "sass": "./style/style.scss"
     },
@@ -40,10 +44,9 @@
     "@angular/material": "^21.0.0",
     "@angular/material-moment-adapter": "^21.0.0",
     "@angular/platform-browser": "^21.0.0",
-    "@igo2/auth": "^21.0.0-next.20",
-    "@igo2/common": "^21.0.0-next.20",
-    "@igo2/core": "^21.0.0-next.20",
-    "@igo2/utils": "^21.0.0-next.20",
+    "@igo2/common": "^21.0.0-next.21",
+    "@igo2/core": "^21.0.0-next.21",
+    "@igo2/utils": "^21.0.0-next.21",
     "@mat-datetimepicker/core": "^17.0.0",
     "geostyler-legend": "^5.2.0",
     "geostyler-openlayers-parser": "^5.7.0",

package/types/igo2-geo-offline.d.ts

@@ -0,0 +1,190 @@
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+import { Provider, EnvironmentProviders } from '@angular/core';
+import { AnyLayerOptions, AnyDataSourceOptions, LayerId, LayerPersistence, AnyLayer, VectorLayerExtension, VectorLayerOptions, VectorLayerExtensionContext, VectorLayerExtensionInstance } from '@igo2/geo';
+import { DBSchema, IDBPDatabase } from 'idb';
+
+declare enum InsertSourceInsertDBEnum {
+    System = "system",
+    User = "user"
+}
+
+interface GeoDBData {
+    url: string;
+    regionID: any;
+    object: any;
+    compressed: boolean;
+    insertSource: InsertSourceInsertDBEnum;
+    insertEvent: string;
+}
+interface GeoDataToIDB {
+    triggerDate: Date | string;
+    action: 'delete' | 'update';
+    urls: string[];
+    source?: string;
+    zippedBaseUrl?: string;
+}
+interface DatasToIDB {
+    geoDatas: GeoDataToIDB[];
+}
+
+declare class GeoDB {
+    private db$;
+    private compression;
+    collisionsMap: Map<string | number, string[]>;
+    _newData: number;
+    private revertObservablesSubscription;
+    constructor();
+    /**
+     * 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: string, regionID: number | string, object: object | Blob, insertSource: InsertSourceInsertDBEnum, insertEvent: string): Observable<GeoDBData>;
+    private customUpdate;
+    add(geoDBData: GeoDBData): Observable<GeoDBData>;
+    put(geoDBData: GeoDBData): Observable<GeoDBData>;
+    getGeoDBData(url: string): Observable<GeoDBData | undefined>;
+    get(url: string): Observable<object | Blob>;
+    delete(key: string): Observable<object>;
+    getRegionCountByID(id: number): Observable<number>;
+    getRegionByID(id: number): Observable<GeoDBData[]>;
+    deleteByRegionID(id: number): Observable<void[]>;
+    resetCounters(): void;
+    resetCollisionsMap(): void;
+    revertCollisions(): void;
+    get newData(): number;
+}
+
+declare class GeoDataSyncService {
+    private http;
+    private messageService;
+    load(urlFile: string): void;
+    private handleConfigFileError;
+    private processGeoDatas;
+    private updateGeoData;
+    private downloadAndStore;
+    private handleDownloadError;
+    private storeZippedGeoData;
+    private extractZipGeojsonEntries;
+    private showDownloadStartMessage;
+    private notifyDownloadCompleted;
+    private isZip;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GeoDataSyncService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GeoDataSyncService>;
+}
+
+interface LayerDBData {
+    layerId: string;
+    layerOptions: AnyLayerOptions;
+    sourceOptions: AnyDataSourceOptions;
+    insertEvent: string;
+    detailedContextUri: string;
+}
+
+declare class LayerDB {
+    private readonly dbPromise;
+    constructor();
+    /**
+     * This method allow to update the stored layer into the indexeddb (layerData)
+     * @param layerDBData
+     * @returns
+     */
+    update(layerDBData: LayerDBData): Observable<LayerDBData>;
+    private updateAsync;
+    add(layerDBData: LayerDBData): Observable<LayerDBData>;
+    private addAsync;
+    /**
+     * This method retrieve an idb layer definition
+     * @param layerId
+     * @returns
+     */
+    getByID(layerId: LayerId): Observable<LayerDBData | undefined>;
+    private getByIDAsync;
+    /**
+     * This method delete an idb layer definition
+     * @param key
+     * @returns
+     */
+    delete(key: string): Observable<object>;
+    private deleteAsync;
+    /**
+     * This method retrive all idb layer definition
+     * @param layerId
+     * @returns
+     */
+    getAll(): Observable<LayerDBData[]>;
+    private getAllAsync;
+}
+
+type ResponseType = 'arraybuffer' | 'json' | 'text' | 'xml' | 'blob';
+interface SimpleGetOptions {
+    responseType: ResponseType;
+    withCredentials?: boolean;
+}
+declare class GeoNetworkService {
+    private http;
+    private networkService;
+    private networkOnline;
+    constructor();
+    get(url: string, simpleGetOptions: SimpleGetOptions): Observable<any>;
+    private getOnline;
+    private getOffline;
+    isOnline(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GeoNetworkService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GeoNetworkService>;
+}
+
+interface IgoDBSchema extends DBSchema {
+    geoData: {
+        value: GeoDBData;
+        key: string;
+        indexes: {
+            'regionID-idx': string;
+        };
+    };
+    layerData: {
+        value: LayerDBData;
+        key: string;
+    };
+}
+
+declare function createIndexedDb(): Promise<IDBPDatabase<IgoDBSchema>>;
+
+declare class IndexedDbLayerPersistenceService implements LayerPersistence {
+    private readonly geoDB;
+    private readonly layerDB;
+    isPersistent(layer: AnyLayer): boolean;
+    removePersistedData(layer: AnyLayer): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IndexedDbLayerPersistenceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IndexedDbLayerPersistenceService>;
+}
+
+declare class IndexedDbVectorLayerExtension implements VectorLayerExtension {
+    readonly id = "indexed-db";
+    readonly priority = 100;
+    private readonly geoDB;
+    private readonly layerDB;
+    private readonly geoNetworkService;
+    supports(options: VectorLayerOptions): boolean;
+    attach(context: VectorLayerExtensionContext): VectorLayerExtensionInstance;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IndexedDbVectorLayerExtension, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IndexedDbVectorLayerExtension>;
+}
+
+declare const OfflineFeatureKind: readonly ["IndexedDb"];
+type OfflineFeatureKind = (typeof OfflineFeatureKind)[number];
+interface OfflineFeature<KindT extends OfflineFeatureKind> {
+    kind: KindT;
+    providers: (Provider | EnvironmentProviders)[];
+}
+
+declare function provideOffline(...features: OfflineFeature<OfflineFeatureKind>[]): EnvironmentProviders;
+declare function withIndexedDb(): OfflineFeature<'IndexedDb'>;
+
+export { GeoDB, GeoDataSyncService, GeoNetworkService, IndexedDbLayerPersistenceService, IndexedDbVectorLayerExtension, InsertSourceInsertDBEnum, LayerDB, OfflineFeatureKind, createIndexedDb, provideOffline, withIndexedDb };
+export type { DatasToIDB, GeoDBData, GeoDataToIDB, IgoDBSchema, LayerDBData, OfflineFeature, ResponseType, SimpleGetOptions };