@ngx-pwa/local-storage 14.0.0 → 16.0.0

package/{esm2020 → esm2022}/lib/databases/exceptions.mjs

@@ -1,7 +1,7 @@
 /**
  * Exception message when `indexedDB` is not working
  */
-export const IDB_BROKEN_ERROR = 'indexedDB is not working';
+export const IDB_BROKEN_ERROR = "indexedDB is not working";
 /**
  * Exception raised when `indexedDB` is not working
  */
@@ -25,4 +25,4 @@ export class SerializationError extends Error {
         this.message = SERIALIZATION_ERROR;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhjZXB0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1wd2EvbG9jYWwtc3RvcmFnZS9zcmMvbGliL2RhdGFiYXNlcy9leGNlcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsMEJBQTBCLENBQUM7QUFFM0Q7O0dBRUc7QUFDSCxNQUFNLE9BQU8sY0FBZSxTQUFRLEtBQUs7SUFBekM7O1FBQ1csWUFBTyxHQUFHLGdCQUFnQixDQUFDO0lBQ3RDLENBQUM7Q0FBQTtBQUVEOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUc7MEVBQ3VDLENBQUM7QUFFM0U7O0dBRUc7QUFDSCxNQUFNLE9BQU8sa0JBQW1CLFNBQVEsS0FBSztJQUE3Qzs7UUFDVyxZQUFPLEdBQUcsbUJBQW1CLENBQUM7SUFDekMsQ0FBQztDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeGNlcHRpb24gbWVzc2FnZSB3aGVuIGBpbmRleGVkREJgIGlzIG5vdCB3b3JraW5nXG4gKi9cbmV4cG9ydCBjb25zdCBJREJfQlJPS0VOX0VSUk9SID0gJ2luZGV4ZWREQiBpcyBub3Qgd29ya2luZyc7XG5cbi8qKlxuICogRXhjZXB0aW9uIHJhaXNlZCB3aGVuIGBpbmRleGVkREJgIGlzIG5vdCB3b3JraW5nXG4gKi9cbmV4cG9ydCBjbGFzcyBJREJCcm9rZW5FcnJvciBleHRlbmRzIEVycm9yIHtcbiAgb3ZlcnJpZGUgbWVzc2FnZSA9IElEQl9CUk9LRU5fRVJST1I7XG59XG5cbi8qKlxuICogRXhjZXB0aW9uIG1lc3NhZ2Ugd2hlbiBhIHZhbHVlIGNhbid0IGJlIHNlcmlhbGl6ZWQgZm9yIGBsb2NhbFN0b3JhZ2VgXG4gKi9cbmV4cG9ydCBjb25zdCBTRVJJQUxJWkFUSU9OX0VSUk9SID0gYFRoZSBzdG9yYWdlIGlzIGN1cnJlbnRseSBsb2NhbFN0b3JhZ2UsXG53aGVyZSBkYXRhIG11c3QgYmUgc2VyaWFsaXplZCwgYW5kIHRoZSBwcm92aWRlZCBkYXRhIGNhbid0IGJlIHNlcmlhbGl6ZWQuYDtcblxuLyoqXG4gKiBFeGNlcHRpb24gcmFpc2VkIHdoZW4gYSB2YWx1ZSBjYW4ndCBiZSBzZXJpYWxpemVkIGZvciBgbG9jYWxTdG9yYWdlYFxuICovXG5leHBvcnQgY2xhc3MgU2VyaWFsaXphdGlvbkVycm9yIGV4dGVuZHMgRXJyb3Ige1xuICBvdmVycmlkZSBtZXNzYWdlID0gU0VSSUFMSVpBVElPTl9FUlJPUjtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhjZXB0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1wd2EvbG9jYWwtc3RvcmFnZS9zcmMvbGliL2RhdGFiYXNlcy9leGNlcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsMEJBQTBCLENBQUM7QUFFM0Q7O0dBRUc7QUFDSCxNQUFNLE9BQU8sY0FBZSxTQUFRLEtBQUs7SUFBekM7O1FBQ1csWUFBTyxHQUFHLGdCQUFnQixDQUFDO0lBQ3RDLENBQUM7Q0FBQTtBQUVEOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUc7MEVBQ3VDLENBQUM7QUFFM0U7O0dBRUc7QUFDSCxNQUFNLE9BQU8sa0JBQW1CLFNBQVEsS0FBSztJQUE3Qzs7UUFDVyxZQUFPLEdBQUcsbUJBQW1CLENBQUM7SUFDekMsQ0FBQztDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeGNlcHRpb24gbWVzc2FnZSB3aGVuIGBpbmRleGVkREJgIGlzIG5vdCB3b3JraW5nXG4gKi9cbmV4cG9ydCBjb25zdCBJREJfQlJPS0VOX0VSUk9SID0gXCJpbmRleGVkREIgaXMgbm90IHdvcmtpbmdcIjtcblxuLyoqXG4gKiBFeGNlcHRpb24gcmFpc2VkIHdoZW4gYGluZGV4ZWREQmAgaXMgbm90IHdvcmtpbmdcbiAqL1xuZXhwb3J0IGNsYXNzIElEQkJyb2tlbkVycm9yIGV4dGVuZHMgRXJyb3Ige1xuICBvdmVycmlkZSBtZXNzYWdlID0gSURCX0JST0tFTl9FUlJPUjtcbn1cblxuLyoqXG4gKiBFeGNlcHRpb24gbWVzc2FnZSB3aGVuIGEgdmFsdWUgY2FuJ3QgYmUgc2VyaWFsaXplZCBmb3IgYGxvY2FsU3RvcmFnZWBcbiAqL1xuZXhwb3J0IGNvbnN0IFNFUklBTElaQVRJT05fRVJST1IgPSBgVGhlIHN0b3JhZ2UgaXMgY3VycmVudGx5IGxvY2FsU3RvcmFnZSxcbndoZXJlIGRhdGEgbXVzdCBiZSBzZXJpYWxpemVkLCBhbmQgdGhlIHByb3ZpZGVkIGRhdGEgY2FuJ3QgYmUgc2VyaWFsaXplZC5gO1xuXG4vKipcbiAqIEV4Y2VwdGlvbiByYWlzZWQgd2hlbiBhIHZhbHVlIGNhbid0IGJlIHNlcmlhbGl6ZWQgZm9yIGBsb2NhbFN0b3JhZ2VgXG4gKi9cbmV4cG9ydCBjbGFzcyBTZXJpYWxpemF0aW9uRXJyb3IgZXh0ZW5kcyBFcnJvciB7XG4gIG92ZXJyaWRlIG1lc3NhZ2UgPSBTRVJJQUxJWkFUSU9OX0VSUk9SO1xufVxuIl19

package/esm2022/lib/databases/indexeddb-database.mjs

@@ -0,0 +1,305 @@
+import { Injectable, inject } from "@angular/core";
+import { ReplaySubject, fromEvent, of, race, throwError } from "rxjs";
+import { first, map, mergeMap, takeWhile, tap } from "rxjs/operators";
+import { IDB_DB_NAME, IDB_DB_VERSION, IDB_NO_WRAP, IDB_STORE_NAME } from "../tokens";
+import { IDBBrokenError } from "./exceptions";
+import * as i0 from "@angular/core";
+class IndexedDBDatabase {
+    constructor() {
+        /**
+         * `indexedDB` database connection, wrapped in a RxJS `ReplaySubject` to be able to access the connection
+         * even after the connection success event happened
+         */
+        this.database = new ReplaySubject(1);
+        /**
+         * Index used when wrapping value. *For backward compatibility only.*
+         */
+        this.wrapIndex = "value";
+        this.dbName = inject(IDB_DB_NAME);
+        this.storeName = inject(IDB_STORE_NAME);
+        this.dbVersion = inject(IDB_DB_VERSION);
+        this.noWrap = inject(IDB_NO_WRAP);
+        /* Connect to `indexedDB`, with prefix if provided by the user */
+        this.connect();
+    }
+    /**
+     * Information about `indexedDB` connection. *Only useful for interoperability.*
+     * @returns `indexedDB` database name, store name and database version
+     */
+    get backingStore() {
+        return {
+            database: this.dbName,
+            store: this.storeName,
+            version: this.dbVersion,
+        };
+    }
+    /**
+     * Number of items in our `indexedDB` database and object store
+     */
+    get size() {
+        /* Open a transaction in read-only mode */
+        return this.transaction("readonly").pipe(mergeMap((transactionData) => {
+            const { store, events } = transactionData;
+            /* Request to know the number of items */
+            const request = store.count();
+            /* Return the result */
+            return events.pipe(map(() => request.result));
+        }), 
+        /* The observable will complete after the first value */
+        first());
+    }
+    /**
+     * Gets an item value in our `indexedDB` store
+     * @param key The item's key
+     * @returns The item's value if the key exists, `undefined` otherwise, wrapped in an RxJS `Observable`
+     */
+    get(key) {
+        /* Open a transaction in read-only mode */
+        return this.transaction("readonly").pipe(mergeMap((transactionData) => {
+            const { store, events } = transactionData;
+            /* Request the value with the key provided by the user */
+            const request = store.get(key);
+            /* Listen events and return the result */
+            return events.pipe(map(() => {
+                if ((request.result !== undefined) && (request.result !== null)) {
+                    /* Prior to v8, the value was wrapped in an `{ value: ...}` object */
+                    if (!this.noWrap && (typeof request.result === "object") && (this.wrapIndex in request.result) &&
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                        (request.result[this.wrapIndex] !== undefined) && (request.result[this.wrapIndex] !== null)) {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                        return request.result[this.wrapIndex];
+                    }
+                    else {
+                        /* Cast to the wanted type */
+                        return request.result;
+                    }
+                }
+                /* Return `undefined` if the value is empty */
+                return undefined;
+            }));
+        }), 
+        /* The observable will complete after the first value */
+        first());
+    }
+    /**
+     * Sets an item in our `indexedDB` store
+     * @param key The item's key
+     * @param data The item's value
+     * @returns An RxJS `Observable` to wait the end of the operation
+     */
+    set(key, data) {
+        /* Storing `undefined` in `indexedDb` can cause issues in some browsers so removing item instead */
+        if (data === undefined) {
+            return this.delete(key);
+        }
+        /* Open a transaction in write mode */
+        return this.transaction("readwrite").pipe(mergeMap((transactionData) => {
+            const { store, events } = transactionData;
+            /* Prior to v8, data was wrapped in a `{ value: ... }` object */
+            const dataToStore = this.noWrap ? data : { [this.wrapIndex]: data };
+            /* Add if the item is not existing yet, or update otherwise */
+            store.put(dataToStore, key);
+            /* Listen to events and return `undefined` as no value is expected */
+            return events.pipe(map(() => undefined));
+        }), 
+        /* The observable will complete after the first value */
+        first());
+    }
+    /**
+     * Deletes an item in our `indexedDB` store
+     * @param key The item's key
+     * @returns An RxJS `Observable` to wait the end of the operation
+     */
+    delete(key) {
+        /* Open a transaction in write mode */
+        return this.transaction("readwrite").pipe(mergeMap((transactionData) => {
+            const { store, events } = transactionData;
+            /* Delete the item in store */
+            store.delete(key);
+            /* Listen to events and return `undefined` as no data is expected here */
+            return events.pipe(map(() => undefined));
+        }), 
+        /* The observable will complete after the first value */
+        first());
+    }
+    /**
+     * Deletes all items from our `indexedDB` objet store
+     * @returns An RxJS `Observable` to wait the end of the operation
+     */
+    clear() {
+        /* Open a transaction in write mode */
+        return this.transaction("readwrite").pipe(mergeMap((transactionData) => {
+            const { store, events } = transactionData;
+            /* Delete all items in object store */
+            store.clear();
+            /* Listen to events and return `undefined` as no data is expected here */
+            return events.pipe(map(() => undefined));
+        }), 
+        /* The observable will complete */
+        first());
+    }
+    /**
+     * Get all the keys in our `indexedDB` store
+     * @returns An RxJS `Observable` iterating on each key
+     */
+    keys() {
+        /* Open a transaction in read-only mode */
+        return this.transaction("readonly").pipe(
+        /* `first()` is used as the final operator in other methods to complete the `Observable`
+         * (as it all starts from a `ReplaySubject` which never ends),
+         * but as this method is iterating over multiple values, `first()` **must** be used here */
+        first(), mergeMap((transactionData) => {
+            const { store } = transactionData;
+            /* Open a cursor on the store
+             * Avoid issues like https://github.com/cyrilletuzi/angular-async-local-storage/issues/69 */
+            const request = store.openKeyCursor();
+            /* Listen to success event */
+            const success$ = fromEvent(request, "success").pipe(
+            /* Stop the `Observable` when the cursor is `null` */
+            takeWhile(() => (request.result !== null)), 
+            /* This lib only allows string keys, but user could have added other types of keys from outside
+             * It's OK to cast as the cursor as been tested in the previous operator */
+            map(() => request.result.key.toString()), 
+            /* Iterate on the cursor */
+            tap(() => { request.result.continue(); }));
+            /* Listen to error event and if so, throw an error */
+            const error$ = this.listenError(request);
+            /* Choose the first event to occur */
+            return race([success$, error$]);
+        }));
+    }
+    /**
+     * Check if a key exists in our `indexedDB` store
+     * @returns An RxJS `Observable` telling if the key exists or not
+     */
+    has(key) {
+        /* Open a transaction in read-only mode */
+        return this.transaction("readonly").pipe(mergeMap((transactionData) => {
+            const { store, events } = transactionData;
+            /* Check if the key exists in the store
+             * Fixes https://github.com/cyrilletuzi/angular-async-local-storage/issues/69
+             */
+            const request = store.getKey(key);
+            /* Listen to events and return `true` or `false` */
+            return events.pipe(map(() => (request.result !== undefined) ? true : false));
+        }), 
+        /* The observable will complete */
+        first());
+    }
+    /**
+     * Connects to `indexedDB` and creates the object store on first time
+     */
+    connect() {
+        let request;
+        /* Connect to `indexedDB`
+         * Will fail in Safari cross-origin iframes
+         * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/issues/42} */
+        try {
+            /* Do NOT explicit `window` here, as `indexedDB` could be used from a web worker too */
+            request = indexedDB.open(this.dbName, this.dbVersion);
+        }
+        catch {
+            this.database.error(new IDBBrokenError());
+            return;
+        }
+        /* Create store on first connection */
+        this.createStore(request);
+        /* Listen to success and error events */
+        const success$ = fromEvent(request, "success");
+        const error$ = this.listenError(request);
+        /* Choose the first to occur */
+        race([success$, error$])
+            /* The observable will complete */
+            .pipe(first())
+            .subscribe({
+            next: () => {
+                /* Register the database connection in the `ReplaySubject` for further access */
+                this.database.next(request.result);
+            },
+            error: () => {
+                /* Firefox private mode issue: fallback storage if IndexedDb connection is failing
+                * @see {@link https://bugzilla.mozilla.org/show_bug.cgi?id=781982}
+                * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/issues/26} */
+                this.database.error(new IDBBrokenError());
+            },
+        });
+    }
+    /**
+     * Create store on first use of `indexedDB`
+     * @param request `indexedDB` database opening request
+     */
+    createStore(request) {
+        /* Listen to the event fired on first connection */
+        fromEvent(request, "upgradeneeded")
+            /* The observable will complete */
+            .pipe(first())
+            .subscribe({
+            next: () => {
+                /* Check if the store already exists, to avoid error */
+                if (!request.result.objectStoreNames.contains(this.storeName)) {
+                    /* Create the object store */
+                    request.result.createObjectStore(this.storeName);
+                }
+            }
+        });
+    }
+    /**
+     * Open an `indexedDB` transaction and get our store
+     * @param mode `readonly` or `readwrite`
+     * @returns An `indexedDB` transaction store and events, wrapped in an RxJS `Observable`
+     */
+    transaction(mode) {
+        /* From the `indexedDB` connection, open a transaction and get the store */
+        return this.database
+            .pipe(mergeMap((database) => {
+            let transaction;
+            try {
+                transaction = database.transaction([this.storeName], mode);
+            }
+            catch (error) {
+                /* The store could have been deleted from outside */
+                return throwError(() => error);
+            }
+            /* Get the store from the transaction */
+            const store = transaction.objectStore(this.storeName);
+            /* Listen transaction `complete` and `error` events */
+            const events = this.listenTransactionEvents(transaction);
+            return of({ store, events });
+        }));
+    }
+    /**
+     * Listen errors on a transaction or request, and throw if trigerred
+     * @param transactionOrRequest `indexedDb` transaction or request to listen
+     * @returns An `Observable` listening to errors
+     */
+    listenError(transactionOrRequest) {
+        return fromEvent(transactionOrRequest, "error").pipe(
+        /* Throw on error to be able to catch errors in RxJS way.
+         * Here `event.target` must be used, as `transactionOrRequest.error` will be `null`
+         * if we are on the request and the error is only triggered later by the transaction */
+        mergeMap((event) => throwError(() => event.target.error)));
+    }
+    /**
+     * Listen transaction `complete` and `error` events
+     * @param transaction Transaction to listen
+     * @returns An `Observable` listening to transaction `complete` and `error` events
+     */
+    listenTransactionEvents(transaction) {
+        /* Listen to the `complete` event */
+        const complete$ = fromEvent(transaction, "complete");
+        /* Listen to the `error` event */
+        const error$ = this.listenError(transaction);
+        /* Choose the first event to occur */
+        return race([complete$, error$]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: IndexedDBDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: IndexedDBDatabase, providedIn: "root" }); }
+}
+export { IndexedDBDatabase };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: IndexedDBDatabase, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"indexeddb-database.js","sourceRoot":"","sources":["../../../../../../projects/ngx-pwa/local-storage/src/lib/databases/indexeddb-database.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from \"@angular/core\";\nimport { Observable, ReplaySubject, fromEvent, of, race, throwError } from \"rxjs\";\nimport { first, map, mergeMap, takeWhile, tap } from \"rxjs/operators\";\nimport { IDB_DB_NAME, IDB_DB_VERSION, IDB_NO_WRAP, IDB_STORE_NAME } from \"../tokens\";\nimport { IDBBrokenError } from \"./exceptions\";\nimport { LocalDatabase } from \"./local-database\";\n\n@Injectable({\n  providedIn: \"root\"\n})\nexport class IndexedDBDatabase implements LocalDatabase {\n\n  /**\n   * `indexedDB` database name\n   */\n  protected readonly dbName: string;\n\n  /**\n   * `indexedDB` object store name\n   */\n  protected readonly storeName: string;\n\n  /**\n   * `indexedDB` database version. Must be an unsigned **integer**\n   */\n  protected readonly dbVersion: number;\n\n  /**\n   * `indexedDB` database connection, wrapped in a RxJS `ReplaySubject` to be able to access the connection\n   * even after the connection success event happened\n   */\n  protected readonly database = new ReplaySubject<IDBDatabase>(1);\n\n  /**\n   * Flag to not wrap `indexedDB` values for interoperability or to wrap for backward compatibility.\n   */\n  protected readonly noWrap: boolean;\n\n  /**\n   * Index used when wrapping value. *For backward compatibility only.*\n   */\n  protected readonly wrapIndex = \"value\";\n\n  constructor() {\n\n    this.dbName = inject(IDB_DB_NAME);\n    this.storeName = inject(IDB_STORE_NAME);\n    this.dbVersion = inject(IDB_DB_VERSION);\n    this.noWrap = inject(IDB_NO_WRAP);\n\n    /* Connect to `indexedDB`, with prefix if provided by the user */\n    this.connect();\n\n  }\n\n  /**\n   * Information about `indexedDB` connection. *Only useful for interoperability.*\n   * @returns `indexedDB` database name, store name and database version\n   */\n  get backingStore(): { database: string, store: string, version: number; } {\n\n    return {\n      database: this.dbName,\n      store: this.storeName,\n      version: this.dbVersion,\n    };\n\n  }\n\n  /**\n   * Number of items in our `indexedDB` database and object store\n   */\n  get size(): Observable<number> {\n\n    /* Open a transaction in read-only mode */\n    return this.transaction(\"readonly\").pipe(\n      mergeMap((transactionData) => {\n\n        const { store, events } = transactionData;\n\n        /* Request to know the number of items */\n        const request = store.count();\n\n        /* Return the result */\n        return events.pipe(map(() => request.result));\n\n      }),\n      /* The observable will complete after the first value */\n      first(),\n    );\n\n  }\n\n  /**\n   * Gets an item value in our `indexedDB` store\n   * @param key The item's key\n   * @returns The item's value if the key exists, `undefined` otherwise, wrapped in an RxJS `Observable`\n   */\n  get(key: string): Observable<unknown | undefined> {\n\n    /* Open a transaction in read-only mode */\n    return this.transaction(\"readonly\").pipe(\n      mergeMap((transactionData) => {\n\n        const { store, events } = transactionData;\n\n        /* Request the value with the key provided by the user */\n        const request = store.get(key);\n\n        /* Listen events and return the result */\n        return events.pipe(map((): unknown => {\n\n          if ((request.result !== undefined) && (request.result !== null)) {\n\n            /* Prior to v8, the value was wrapped in an `{ value: ...}` object */\n            if (!this.noWrap && (typeof request.result === \"object\") && (this.wrapIndex in request.result) &&\n              // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n              (request.result[this.wrapIndex] !== undefined) && (request.result[this.wrapIndex] !== null)) {\n\n              // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n              return request.result[this.wrapIndex];\n\n            } else {\n\n              /* Cast to the wanted type */\n              return request.result;\n\n            }\n\n          }\n\n          /* Return `undefined` if the value is empty */\n          return undefined;\n\n        }));\n\n      }),\n      /* The observable will complete after the first value */\n      first(),\n    );\n\n  }\n\n  /**\n   * Sets an item in our `indexedDB` store\n   * @param key The item's key\n   * @param data The item's value\n   * @returns An RxJS `Observable` to wait the end of the operation\n   */\n  set(key: string, data: unknown): Observable<undefined> {\n\n    /* Storing `undefined` in `indexedDb` can cause issues in some browsers so removing item instead */\n    if (data === undefined) {\n      return this.delete(key);\n    }\n\n    /* Open a transaction in write mode */\n    return this.transaction(\"readwrite\").pipe(\n      mergeMap((transactionData) => {\n\n        const { store, events } = transactionData;\n\n        /* Prior to v8, data was wrapped in a `{ value: ... }` object */\n        const dataToStore = this.noWrap ? data : { [this.wrapIndex]: data };\n\n        /* Add if the item is not existing yet, or update otherwise */\n        store.put(dataToStore, key);\n\n        /* Listen to events and return `undefined` as no value is expected */\n        return events.pipe(map(() => undefined));\n\n      }),\n      /* The observable will complete after the first value */\n      first(),\n    );\n\n  }\n\n  /**\n   * Deletes an item in our `indexedDB` store\n   * @param key The item's key\n   * @returns An RxJS `Observable` to wait the end of the operation\n   */\n  delete(key: string): Observable<undefined> {\n\n    /* Open a transaction in write mode */\n    return this.transaction(\"readwrite\").pipe(\n      mergeMap((transactionData) => {\n\n        const { store, events } = transactionData;\n\n        /* Delete the item in store */\n        store.delete(key);\n\n        /* Listen to events and return `undefined` as no data is expected here */\n        return events.pipe(map(() => undefined));\n\n      }),\n      /* The observable will complete after the first value */\n      first(),\n    );\n\n  }\n\n  /**\n   * Deletes all items from our `indexedDB` objet store\n   * @returns An RxJS `Observable` to wait the end of the operation\n   */\n  clear(): Observable<undefined> {\n\n    /* Open a transaction in write mode */\n    return this.transaction(\"readwrite\").pipe(\n      mergeMap((transactionData) => {\n\n        const { store, events } = transactionData;\n\n        /* Delete all items in object store */\n        store.clear();\n\n        /* Listen to events and return `undefined` as no data is expected here */\n        return events.pipe(map(() => undefined));\n\n      }),\n      /* The observable will complete */\n      first(),\n    );\n\n  }\n\n  /**\n   * Get all the keys in our `indexedDB` store\n   * @returns An RxJS `Observable` iterating on each key\n   */\n  keys(): Observable<string> {\n\n    /* Open a transaction in read-only mode */\n    return this.transaction(\"readonly\").pipe(\n      /* `first()` is used as the final operator in other methods to complete the `Observable`\n       * (as it all starts from a `ReplaySubject` which never ends),\n       * but as this method is iterating over multiple values, `first()` **must** be used here */\n      first(),\n      mergeMap((transactionData) => {\n\n        const { store } = transactionData;\n\n        /* Open a cursor on the store\n         * Avoid issues like https://github.com/cyrilletuzi/angular-async-local-storage/issues/69 */\n        const request = store.openKeyCursor();\n\n        /* Listen to success event */\n        const success$ = fromEvent(request, \"success\").pipe(\n          /* Stop the `Observable` when the cursor is `null` */\n          takeWhile(() => (request.result !== null)),\n          /* This lib only allows string keys, but user could have added other types of keys from outside\n           * It's OK to cast as the cursor as been tested in the previous operator */\n          map(() => (request.result as IDBCursor).key.toString()),\n          /* Iterate on the cursor */\n          tap(() => { (request.result as IDBCursor).continue(); }),\n        );\n\n        /* Listen to error event and if so, throw an error */\n        const error$ = this.listenError(request);\n\n        /* Choose the first event to occur */\n        return race([success$, error$]);\n\n      }),\n    );\n\n  }\n\n  /**\n   * Check if a key exists in our `indexedDB` store\n   * @returns An RxJS `Observable` telling if the key exists or not\n   */\n  has(key: string): Observable<boolean> {\n\n    /* Open a transaction in read-only mode */\n    return this.transaction(\"readonly\").pipe(\n      mergeMap((transactionData) => {\n\n        const { store, events } = transactionData;\n\n        /* Check if the key exists in the store\n         * Fixes https://github.com/cyrilletuzi/angular-async-local-storage/issues/69\n         */\n        const request = store.getKey(key);\n\n        /* Listen to events and return `true` or `false` */\n        return events.pipe(map(() => (request.result !== undefined) ? true : false));\n\n      }),\n      /* The observable will complete */\n      first(),\n    );\n\n  }\n\n  /**\n   * Connects to `indexedDB` and creates the object store on first time\n   */\n  protected connect(): void {\n\n    let request: IDBOpenDBRequest;\n\n    /* Connect to `indexedDB`\n     * Will fail in Safari cross-origin iframes\n     * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/issues/42} */\n    try {\n\n      /* Do NOT explicit `window` here, as `indexedDB` could be used from a web worker too */\n      request = indexedDB.open(this.dbName, this.dbVersion);\n\n    } catch {\n\n      this.database.error(new IDBBrokenError());\n\n      return;\n\n    }\n\n    /* Create store on first connection */\n    this.createStore(request);\n\n    /* Listen to success and error events */\n    const success$ = fromEvent(request, \"success\");\n    const error$ = this.listenError(request);\n\n    /* Choose the first to occur */\n    race([success$, error$])\n      /* The observable will complete */\n      .pipe(first())\n      .subscribe({\n        next: () => {\n          /* Register the database connection in the `ReplaySubject` for further access */\n          this.database.next(request.result);\n        },\n        error: () => {\n          /* Firefox private mode issue: fallback storage if IndexedDb connection is failing\n          * @see {@link https://bugzilla.mozilla.org/show_bug.cgi?id=781982}\n          * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/issues/26} */\n          this.database.error(new IDBBrokenError());\n        },\n      });\n\n  }\n\n  /**\n   * Create store on first use of `indexedDB`\n   * @param request `indexedDB` database opening request\n   */\n  protected createStore(request: IDBOpenDBRequest): void {\n\n    /* Listen to the event fired on first connection */\n    fromEvent(request, \"upgradeneeded\")\n      /* The observable will complete */\n      .pipe(first())\n      .subscribe({\n        next: () => {\n\n          /* Check if the store already exists, to avoid error */\n          if (!request.result.objectStoreNames.contains(this.storeName)) {\n\n            /* Create the object store */\n            request.result.createObjectStore(this.storeName);\n\n          }\n\n        }\n      });\n\n  }\n\n  /**\n   * Open an `indexedDB` transaction and get our store\n   * @param mode `readonly` or `readwrite`\n   * @returns An `indexedDB` transaction store and events, wrapped in an RxJS `Observable`\n   */\n  protected transaction(mode: IDBTransactionMode): Observable<{\n    store: IDBObjectStore;\n    events: Observable<Event>;\n  }> {\n\n    /* From the `indexedDB` connection, open a transaction and get the store */\n    return this.database\n      .pipe(mergeMap((database) => {\n\n        let transaction: IDBTransaction;\n\n        try {\n\n          transaction = database.transaction([this.storeName], mode);\n\n        } catch (error) {\n\n          /* The store could have been deleted from outside */\n          return throwError(() => error as DOMException);\n\n        }\n\n        /* Get the store from the transaction */\n        const store = transaction.objectStore(this.storeName);\n\n        /* Listen transaction `complete` and `error` events */\n        const events = this.listenTransactionEvents(transaction);\n\n        return of({ store, events });\n\n      }));\n\n  }\n\n  /**\n   * Listen errors on a transaction or request, and throw if trigerred\n   * @param transactionOrRequest `indexedDb` transaction or request to listen\n   * @returns An `Observable` listening to errors\n   */\n  protected listenError(transactionOrRequest: IDBTransaction | IDBRequest): Observable<never> {\n\n    return fromEvent(transactionOrRequest, \"error\").pipe(\n      /* Throw on error to be able to catch errors in RxJS way.\n       * Here `event.target` must be used, as `transactionOrRequest.error` will be `null`\n       * if we are on the request and the error is only triggered later by the transaction */\n      mergeMap((event) => throwError(() => (event.target as IDBTransaction | IDBRequest).error)),\n    );\n\n  }\n\n  /**\n   * Listen transaction `complete` and `error` events\n   * @param transaction Transaction to listen\n   * @returns An `Observable` listening to transaction `complete` and `error` events\n   */\n  protected listenTransactionEvents(transaction: IDBTransaction): Observable<Event> {\n\n    /* Listen to the `complete` event */\n    const complete$ = fromEvent(transaction, \"complete\");\n\n    /* Listen to the `error` event */\n    const error$ = this.listenError(transaction);\n\n    /* Choose the first event to occur */\n    return race([complete$, error$]);\n\n  }\n\n}\n"]}

package/esm2022/lib/databases/local-database.mjs

@@ -0,0 +1,67 @@
+import { isPlatformBrowser } from "@angular/common";
+import { inject, Injectable, PLATFORM_ID } from "@angular/core";
+import { IndexedDBDatabase } from "./indexeddb-database";
+import { LocalStorageDatabase } from "./localstorage-database";
+import { MemoryDatabase } from "./memory-database";
+import * as i0 from "@angular/core";
+/**
+ * Factory to create a storage according to browser support
+ * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/blob/main/docs/BROWSERS_SUPPORT.md}
+ */
+export function localDatabaseFactory() {
+    const platformId = inject(PLATFORM_ID);
+    /* When storage is fully disabled in browser (via the "Block all cookies" option),
+     * just trying to check `indexedDB` or `localStorage` variables causes a security exception.
+     * Prevents https://github.com/cyrilletuzi/angular-async-local-storage/issues/118
+     */
+    try {
+        // Do not explicit `window` here, as the global object is not the same in web workers
+        if (isPlatformBrowser(platformId) && (indexedDB !== undefined) && (indexedDB !== null) && ("open" in indexedDB)) {
+            /* Check:
+            * - if we are in a browser context (issue: server-side rendering)
+            * - it could exist but be `undefined` or `null`
+            * - it could exists but not having a working API
+            * Will be the case for:
+            * - All other browsers in normal mode
+            * - Chromium / Safari private mode, but in this case, data will be swiped when the user leaves the app */
+            return new IndexedDBDatabase();
+        }
+        else if (isPlatformBrowser(platformId)
+            && (localStorage !== undefined) && (localStorage !== null) && ("getItem" in localStorage)) {
+            /* Check:
+            * - if we are in a browser context (issue: server-side rendering)
+            * - if `localStorage` exists (to be sure)
+            * - it could exists but not having a working API
+            * Will be the case for:
+            * - Safari cross-origin iframes, detected later in `IndexedDBDatabase.connect()`
+            * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/issues/42}
+            * - Firefox private mode, but in this case, data will be swiped when the user leaves the app
+            * For Firefox, can only be detected later in `IndexedDBDatabase.connect()`
+            * @see {@link https://bugzilla.mozilla.org/show_bug.cgi?id=781982}
+            */
+            return new LocalStorageDatabase();
+        }
+    }
+    catch {
+        // Nothing to do
+    }
+    /* Will be the case for:
+     * - In browsers if storage has been fully disabled (via the "Block all cookies" option)
+     * - Server-side rendering
+     * - All other non-browser context
+     */
+    return new MemoryDatabase();
+}
+class LocalDatabase {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalDatabase, providedIn: "root", useFactory: localDatabaseFactory }); }
+}
+export { LocalDatabase };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalDatabase, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                    useFactory: localDatabaseFactory,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/databases/localstorage-database.mjs

@@ -0,0 +1,158 @@
+import { Injectable, inject } from "@angular/core";
+import { Observable, asyncScheduler, of, throwError } from "rxjs";
+import { observeOn } from "rxjs/operators";
+import { LS_PREFIX } from "../tokens";
+import { SerializationError } from "./exceptions";
+import * as i0 from "@angular/core";
+class LocalStorageDatabase {
+    constructor() {
+        console.log('test');
+        /* Prefix if asked, or no prefix otherwise */
+        this.prefix = inject(LS_PREFIX) || "";
+    }
+    /**
+     * Number of items in `localStorage`
+     */
+    get size() {
+        /* Wrap in a RxJS `Observable` to be consistent with other storages */
+        return of(localStorage.length);
+    }
+    /**
+     * Gets an item value in `localStorage`
+     * @param key The item's key
+     * @returns The item's value if the key exists, `undefined` otherwise, wrapped in a RxJS `Observable`
+     */
+    get(key) {
+        /* Get raw data */
+        const unparsedData = localStorage.getItem(this.prefixKey(key));
+        let parsedData;
+        /* No need to parse if data is `null` or `undefined` */
+        if ((unparsedData !== undefined) && (unparsedData !== null)) {
+            /* Try to parse */
+            try {
+                parsedData = JSON.parse(unparsedData);
+            }
+            catch (error) {
+                return throwError(() => error);
+            }
+        }
+        /* Wrap in a RxJS `Observable` to be consistent with other storages */
+        return of(parsedData);
+    }
+    /**
+     * Store an item in `localStorage`
+     * @param key The item's key
+     * @param data The item's value
+     * @returns A RxJS `Observable` to wait the end of the operation
+     */
+    set(key, data) {
+        let serializedData = null;
+        /* Check if data can be serialized */
+        const dataPrototype = Object.getPrototypeOf(data);
+        if ((typeof data === "object") && (data !== null) && !Array.isArray(data) &&
+            !((dataPrototype === Object.prototype) || (dataPrototype === null))) {
+            return throwError(() => new SerializationError());
+        }
+        /* Try to stringify (can fail on circular references) */
+        try {
+            serializedData = JSON.stringify(data);
+        }
+        catch (error) {
+            return throwError(() => error);
+        }
+        /* Can fail if storage quota is exceeded */
+        try {
+            localStorage.setItem(this.prefixKey(key), serializedData);
+        }
+        catch (error) {
+            return throwError(() => error);
+        }
+        /* Wrap in a RxJS `Observable` to be consistent with other storages */
+        return of(undefined);
+    }
+    /**
+     * Deletes an item in `localStorage`
+     * @param key The item's key
+     * @returns A RxJS `Observable` to wait the end of the operation
+     */
+    delete(key) {
+        localStorage.removeItem(this.prefixKey(key));
+        /* Wrap in a RxJS `Observable` to be consistent with other storages */
+        return of(undefined);
+    }
+    /**
+     * Deletes all items in `localStorage`
+     * @returns A RxJS `Observable` to wait the end of the operation
+     */
+    clear() {
+        localStorage.clear();
+        /* Wrap in a RxJS `Observable` to be consistent with other storages */
+        return of(undefined);
+    }
+    /**
+     * Get all keys in `localStorage`
+     * Note the order of the keys may be inconsistent in Firefox
+     * @returns A RxJS `Observable` iterating on keys
+     */
+    keys() {
+        /* Create an `Observable` from keys */
+        return new Observable((subscriber) => {
+            /* Iteretate over all the indexes */
+            for (let index = 0; index < localStorage.length; index += 1) {
+                /* Cast as we are sure in this case the key is not `null` */
+                subscriber.next(this.getUnprefixedKey(index));
+            }
+            subscriber.complete();
+        }).pipe(
+        /* Required to work like other databases which are asynchronous */
+        observeOn(asyncScheduler));
+    }
+    /**
+     * Check if a key exists in `localStorage`
+     * @param key The item's key
+     * @returns A RxJS `Observable` telling if the key exists or not
+     */
+    has(key) {
+        /* Itérate over all indexes in storage */
+        for (let index = 0; index < localStorage.length; index += 1) {
+            if (key === this.getUnprefixedKey(index)) {
+                /* Wrap in a RxJS `Observable` to be consistent with other storages */
+                return of(true);
+            }
+        }
+        /* Wrap in a RxJS `Observable` to be consistent with other storages */
+        return of(false);
+    }
+    /**
+     * Get an unprefixed key
+     * @param index Index of the key
+     * @returns The unprefixed key name if exists, `null` otherwise
+     */
+    getUnprefixedKey(index) {
+        /* Get the key in storage: may have a prefix */
+        const prefixedKey = localStorage.key(index);
+        if (prefixedKey !== null) {
+            /* If no prefix, the key is already good, otherwrite strip the prefix */
+            return !this.prefix ? prefixedKey : prefixedKey.substring(this.prefix.length);
+        }
+        return null;
+    }
+    /**
+     * Add the prefix to a key
+     * @param key The key name
+     * @returns The prefixed key name
+     */
+    prefixKey(key) {
+        return `${this.prefix}${key}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalStorageDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalStorageDatabase, providedIn: "root" }); }
+}
+export { LocalStorageDatabase };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalStorageDatabase, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"localstorage-database.js","sourceRoot":"","sources":["../../../../../../projects/ngx-pwa/local-storage/src/lib/databases/localstorage-database.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from \"@angular/core\";\nimport { Observable, asyncScheduler, of, throwError } from \"rxjs\";\nimport { observeOn } from \"rxjs/operators\";\nimport { LS_PREFIX } from \"../tokens\";\nimport { SerializationError } from \"./exceptions\";\nimport { LocalDatabase } from \"./local-database\";\n\n@Injectable({\n  providedIn: \"root\"\n})\nexport class LocalStorageDatabase implements LocalDatabase {\n\n  /**\n   * Optional user prefix to avoid collision for multiple apps on the same subdomain\n   */\n  readonly prefix: string;\n\n  constructor() {\n\n    console.log('test');\n\n    /* Prefix if asked, or no prefix otherwise */\n    this.prefix = inject(LS_PREFIX) || \"\";\n\n  }\n\n  /**\n   * Number of items in `localStorage`\n   */\n  get size(): Observable<number> {\n\n    /* Wrap in a RxJS `Observable` to be consistent with other storages */\n    return of(localStorage.length);\n\n  }\n\n  /**\n   * Gets an item value in `localStorage`\n   * @param key The item's key\n   * @returns The item's value if the key exists, `undefined` otherwise, wrapped in a RxJS `Observable`\n   */\n  get(key: string): Observable<unknown | undefined> {\n\n    /* Get raw data */\n    const unparsedData = localStorage.getItem(this.prefixKey(key));\n\n    let parsedData: unknown;\n\n    /* No need to parse if data is `null` or `undefined` */\n    if ((unparsedData !== undefined) && (unparsedData !== null)) {\n\n      /* Try to parse */\n      try {\n        parsedData = JSON.parse(unparsedData);\n      } catch (error) {\n        return throwError(() => error as SyntaxError);\n      }\n\n    }\n\n    /* Wrap in a RxJS `Observable` to be consistent with other storages */\n    return of(parsedData);\n\n  }\n\n  /**\n   * Store an item in `localStorage`\n   * @param key The item's key\n   * @param data The item's value\n   * @returns A RxJS `Observable` to wait the end of the operation\n   */\n  set(key: string, data: unknown): Observable<undefined> {\n\n    let serializedData: string | null = null;\n\n    /* Check if data can be serialized */\n    const dataPrototype: unknown = Object.getPrototypeOf(data);\n    if ((typeof data === \"object\") && (data !== null) && !Array.isArray(data) &&\n      !((dataPrototype === Object.prototype) || (dataPrototype === null))) {\n      return throwError(() => new SerializationError());\n    }\n\n    /* Try to stringify (can fail on circular references) */\n    try {\n      serializedData = JSON.stringify(data);\n    } catch (error) {\n      return throwError(() => error as TypeError);\n    }\n\n    /* Can fail if storage quota is exceeded */\n    try {\n      localStorage.setItem(this.prefixKey(key), serializedData);\n    } catch (error) {\n      return throwError(() => error as DOMException);\n    }\n\n    /* Wrap in a RxJS `Observable` to be consistent with other storages */\n    return of(undefined);\n\n  }\n\n  /**\n   * Deletes an item in `localStorage`\n   * @param key The item's key\n   * @returns A RxJS `Observable` to wait the end of the operation\n   */\n  delete(key: string): Observable<undefined> {\n\n    localStorage.removeItem(this.prefixKey(key));\n\n    /* Wrap in a RxJS `Observable` to be consistent with other storages */\n    return of(undefined);\n\n  }\n\n  /**\n   * Deletes all items in `localStorage`\n   * @returns A RxJS `Observable` to wait the end of the operation\n   */\n  clear(): Observable<undefined> {\n\n    localStorage.clear();\n\n    /* Wrap in a RxJS `Observable` to be consistent with other storages */\n    return of(undefined);\n\n  }\n\n  /**\n   * Get all keys in `localStorage`\n   * Note the order of the keys may be inconsistent in Firefox\n   * @returns A RxJS `Observable` iterating on keys\n   */\n  keys(): Observable<string> {\n\n    /* Create an `Observable` from keys */\n    return new Observable<string>((subscriber) => {\n\n      /* Iteretate over all the indexes */\n      for (let index = 0; index < localStorage.length; index += 1) {\n\n        /* Cast as we are sure in this case the key is not `null` */\n        subscriber.next(this.getUnprefixedKey(index) as string);\n\n      }\n\n      subscriber.complete();\n\n    }).pipe(\n      /* Required to work like other databases which are asynchronous */\n      observeOn(asyncScheduler),\n    );\n\n  }\n\n  /**\n   * Check if a key exists in `localStorage`\n   * @param key The item's key\n   * @returns A RxJS `Observable` telling if the key exists or not\n   */\n  has(key: string): Observable<boolean> {\n\n    /* Itérate over all indexes in storage */\n    for (let index = 0; index < localStorage.length; index += 1) {\n\n      if (key === this.getUnprefixedKey(index)) {\n\n        /* Wrap in a RxJS `Observable` to be consistent with other storages */\n        return of(true);\n\n      }\n\n    }\n\n    /* Wrap in a RxJS `Observable` to be consistent with other storages */\n    return of(false);\n\n  }\n\n  /**\n   * Get an unprefixed key\n   * @param index Index of the key\n   * @returns The unprefixed key name if exists, `null` otherwise\n   */\n  protected getUnprefixedKey(index: number): string | null {\n\n    /* Get the key in storage: may have a prefix */\n    const prefixedKey = localStorage.key(index);\n\n    if (prefixedKey !== null) {\n\n      /* If no prefix, the key is already good, otherwrite strip the prefix */\n      return !this.prefix ? prefixedKey : prefixedKey.substring(this.prefix.length);\n\n    }\n\n    return null;\n\n  }\n\n  /**\n   * Add the prefix to a key\n   * @param key The key name\n   * @returns The prefixed key name\n   */\n  protected prefixKey(key: string): string {\n\n    return `${this.prefix}${key}`;\n\n  }\n\n}\n"]}