@ngx-pwa/local-storage 12.0.0-0 → 13.0.0

package/README.md

@@ -10,12 +10,15 @@ Efficient client-side storage module for Angular:
 
 ## Sponsorship
 
-What started as a personal project is now one of the most used Angular library
-for client-side storage, with more than 10 000 downloads
-[on npm](https://www.npmjs.com/package/@ngx-pwa/local-storage) each week.
-
-It's a lot of *unpaid* work. So please consider:
-- **becoming [a sponsor](https://github.com/sponsors/cyrilletuzi)**, if your company earns money with projects using this lib
+You like this library downloaded more than 15 000 times each week
+[on npm](https://www.npmjs.com/package/@ngx-pwa/local-storage)?
+You like the serious open source work
+(full documentation, lib ready on day one of Angular major updates,...)?
+And your company is using it in projects generating money?
+
+Well, on my side, it's a lot of *unpaid* work. So please consider:
+- becoming a **[regular sponsor](https://github.com/sponsors/cyrilletuzi)**
+- doing a **[one-time donation](https://github.com/sponsors/cyrilletuzi?frequency=one-time)**
 - at least, taking 2 minutes to [show your love](https://github.com/cyrilletuzi/angular-async-local-storage/discussions/categories/wall-of-love)
 
 ## By the same author
@@ -53,7 +56,7 @@ to be homogeneous with other Angular modules.
 Install the package, according to your Angular version:
 
 ```bash
-# For Angular LTS (Angular >= 9):
+# For Angular LTS (Angular >= 10):
 ng add @ngx-pwa/local-storage
 ```
 

package/{esm2015/lib/databases/exceptions.js → esm2020/lib/databases/exceptions.mjs}

@@ -25,4 +25,4 @@ export class SerializationError extends Error {
         this.message = SERIALIZATION_ERROR;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhjZXB0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1wd2EvbG9jYWwtc3RvcmFnZS9zcmMvbGliL2RhdGFiYXNlcy9leGNlcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsMEJBQTBCLENBQUM7QUFFM0Q7O0dBRUc7QUFDSCxNQUFNLE9BQU8sY0FBZSxTQUFRLEtBQUs7SUFBekM7O1FBQ0UsWUFBTyxHQUFHLGdCQUFnQixDQUFDO0lBQzdCLENBQUM7Q0FBQTtBQUVEOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUc7MEVBQ3VDLENBQUM7QUFFM0U7O0dBRUc7QUFDSCxNQUFNLE9BQU8sa0JBQW1CLFNBQVEsS0FBSztJQUE3Qzs7UUFDRSxZQUFPLEdBQUcsbUJBQW1CLENBQUM7SUFDaEMsQ0FBQztDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeGNlcHRpb24gbWVzc2FnZSB3aGVuIGBpbmRleGVkREJgIGlzIG5vdCB3b3JraW5nXG4gKi9cbmV4cG9ydCBjb25zdCBJREJfQlJPS0VOX0VSUk9SID0gJ2luZGV4ZWREQiBpcyBub3Qgd29ya2luZyc7XG5cbi8qKlxuICogRXhjZXB0aW9uIHJhaXNlZCB3aGVuIGBpbmRleGVkREJgIGlzIG5vdCB3b3JraW5nXG4gKi9cbmV4cG9ydCBjbGFzcyBJREJCcm9rZW5FcnJvciBleHRlbmRzIEVycm9yIHtcbiAgbWVzc2FnZSA9IElEQl9CUk9LRU5fRVJST1I7XG59XG5cbi8qKlxuICogRXhjZXB0aW9uIG1lc3NhZ2Ugd2hlbiBhIHZhbHVlIGNhbid0IGJlIHNlcmlhbGl6ZWQgZm9yIGBsb2NhbFN0b3JhZ2VgXG4gKi9cbmV4cG9ydCBjb25zdCBTRVJJQUxJWkFUSU9OX0VSUk9SID0gYFRoZSBzdG9yYWdlIGlzIGN1cnJlbnRseSBsb2NhbFN0b3JhZ2UsXG53aGVyZSBkYXRhIG11c3QgYmUgc2VyaWFsaXplZCwgYW5kIHRoZSBwcm92aWRlZCBkYXRhIGNhbid0IGJlIHNlcmlhbGl6ZWQuYDtcblxuLyoqXG4gKiBFeGNlcHRpb24gcmFpc2VkIHdoZW4gYSB2YWx1ZSBjYW4ndCBiZSBzZXJpYWxpemVkIGZvciBgbG9jYWxTdG9yYWdlYFxuICovXG5leHBvcnQgY2xhc3MgU2VyaWFsaXphdGlvbkVycm9yIGV4dGVuZHMgRXJyb3Ige1xuICBtZXNzYWdlID0gU0VSSUFMSVpBVElPTl9FUlJPUjtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhjZXB0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1wd2EvbG9jYWwtc3RvcmFnZS9zcmMvbGliL2RhdGFiYXNlcy9leGNlcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsMEJBQTBCLENBQUM7QUFFM0Q7O0dBRUc7QUFDSCxNQUFNLE9BQU8sY0FBZSxTQUFRLEtBQUs7SUFBekM7O1FBQ1csWUFBTyxHQUFHLGdCQUFnQixDQUFDO0lBQ3RDLENBQUM7Q0FBQTtBQUVEOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUc7MEVBQ3VDLENBQUM7QUFFM0U7O0dBRUc7QUFDSCxNQUFNLE9BQU8sa0JBQW1CLFNBQVEsS0FBSztJQUE3Qzs7UUFDVyxZQUFPLEdBQUcsbUJBQW1CLENBQUM7SUFDekMsQ0FBQztDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeGNlcHRpb24gbWVzc2FnZSB3aGVuIGBpbmRleGVkREJgIGlzIG5vdCB3b3JraW5nXG4gKi9cbmV4cG9ydCBjb25zdCBJREJfQlJPS0VOX0VSUk9SID0gJ2luZGV4ZWREQiBpcyBub3Qgd29ya2luZyc7XG5cbi8qKlxuICogRXhjZXB0aW9uIHJhaXNlZCB3aGVuIGBpbmRleGVkREJgIGlzIG5vdCB3b3JraW5nXG4gKi9cbmV4cG9ydCBjbGFzcyBJREJCcm9rZW5FcnJvciBleHRlbmRzIEVycm9yIHtcbiAgb3ZlcnJpZGUgbWVzc2FnZSA9IElEQl9CUk9LRU5fRVJST1I7XG59XG5cbi8qKlxuICogRXhjZXB0aW9uIG1lc3NhZ2Ugd2hlbiBhIHZhbHVlIGNhbid0IGJlIHNlcmlhbGl6ZWQgZm9yIGBsb2NhbFN0b3JhZ2VgXG4gKi9cbmV4cG9ydCBjb25zdCBTRVJJQUxJWkFUSU9OX0VSUk9SID0gYFRoZSBzdG9yYWdlIGlzIGN1cnJlbnRseSBsb2NhbFN0b3JhZ2UsXG53aGVyZSBkYXRhIG11c3QgYmUgc2VyaWFsaXplZCwgYW5kIHRoZSBwcm92aWRlZCBkYXRhIGNhbid0IGJlIHNlcmlhbGl6ZWQuYDtcblxuLyoqXG4gKiBFeGNlcHRpb24gcmFpc2VkIHdoZW4gYSB2YWx1ZSBjYW4ndCBiZSBzZXJpYWxpemVkIGZvciBgbG9jYWxTdG9yYWdlYFxuICovXG5leHBvcnQgY2xhc3MgU2VyaWFsaXphdGlvbkVycm9yIGV4dGVuZHMgRXJyb3Ige1xuICBvdmVycmlkZSBtZXNzYWdlID0gU0VSSUFMSVpBVElPTl9FUlJPUjtcbn1cbiJdfQ==

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

@@ -0,0 +1,326 @@
+import { Injectable, Inject } from '@angular/core';
+import { ReplaySubject, fromEvent, of, throwError, race } from 'rxjs';
+import { map, mergeMap, first, takeWhile, tap, mapTo } from 'rxjs/operators';
+import { IDB_DB_NAME, IDB_STORE_NAME, DEFAULT_IDB_STORE_NAME, IDB_DB_VERSION, DEFAULT_IDB_DB_NAME, DEFAULT_IDB_DB_VERSION, IDB_NO_WRAP, DEFAULT_IDB_NO_WRAP } from '../tokens';
+import { IDBBrokenError } from './exceptions';
+import * as i0 from "@angular/core";
+export class IndexedDBDatabase {
+    /**
+     * Constructor params are provided by Angular (but can also be passed manually in tests)
+     * @param dbName `indexedDB` database name
+     * @param storeName `indexedDB` store name
+     * @param dbVersion `indexedDB` database version
+     * @param noWrap Flag to not wrap `indexedDB` values for interoperability or to wrap for backward compatibility
+     */
+    constructor(dbName = DEFAULT_IDB_DB_NAME, storeName = DEFAULT_IDB_STORE_NAME, dbVersion = DEFAULT_IDB_DB_VERSION, noWrap = DEFAULT_IDB_NO_WRAP) {
+        /**
+         * `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 = dbName;
+        this.storeName = storeName;
+        this.dbVersion = dbVersion;
+        this.noWrap = noWrap;
+        /* 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 */
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            return events.pipe(mapTo(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 */
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            return events.pipe(mapTo(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 */
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            return events.pipe(mapTo(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$]);
+    }
+}
+IndexedDBDatabase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: IndexedDBDatabase, deps: [{ token: IDB_DB_NAME }, { token: IDB_STORE_NAME }, { token: IDB_DB_VERSION }, { token: IDB_NO_WRAP }], target: i0.ɵɵFactoryTarget.Injectable });
+IndexedDBDatabase.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: IndexedDBDatabase, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: IndexedDBDatabase, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [IDB_DB_NAME]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [IDB_STORE_NAME]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [IDB_DB_VERSION]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [IDB_NO_WRAP]
+                }] }]; } });
+//# 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, throwError, race } from 'rxjs';\nimport { map, mergeMap, first, takeWhile, tap, mapTo } from 'rxjs/operators';\n\nimport {\n  IDB_DB_NAME, IDB_STORE_NAME, DEFAULT_IDB_STORE_NAME, IDB_DB_VERSION,\n  DEFAULT_IDB_DB_NAME, DEFAULT_IDB_DB_VERSION, IDB_NO_WRAP, DEFAULT_IDB_NO_WRAP\n} 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  /**\n   * Constructor params are provided by Angular (but can also be passed manually in tests)\n   * @param dbName `indexedDB` database name\n   * @param storeName `indexedDB` store name\n   * @param dbVersion `indexedDB` database version\n   * @param noWrap Flag to not wrap `indexedDB` values for interoperability or to wrap for backward compatibility\n   */\n  constructor(\n    @Inject(IDB_DB_NAME) dbName = DEFAULT_IDB_DB_NAME,\n    @Inject(IDB_STORE_NAME) storeName = DEFAULT_IDB_STORE_NAME,\n    @Inject(IDB_DB_VERSION) dbVersion = DEFAULT_IDB_DB_VERSION,\n    @Inject(IDB_NO_WRAP) noWrap = DEFAULT_IDB_NO_WRAP,\n  ) {\n\n    this.dbName = dbName;\n    this.storeName = storeName;\n    this.dbVersion = dbVersion;\n    this.noWrap = noWrap;\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        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n        return events.pipe(mapTo(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        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n        return events.pipe(mapTo(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        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n        return events.pipe(mapTo(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/esm2020/lib/databases/local-database.mjs

@@ -0,0 +1,78 @@
+import { Injectable, PLATFORM_ID } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { IDB_STORE_NAME, IDB_DB_NAME, LS_PREFIX, IDB_DB_VERSION, IDB_NO_WRAP } from '../tokens';
+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
+ * @param platformId Context about the platform (`browser`, `server`...)
+ * @param LSPrefix Prefix for `localStorage` keys to avoid collision for multiple apps on the same subdomain
+ * @param IDBDBName `indexedDB` database name
+ * @param IDBstoreName `indexedDB` storeName name
+ * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/blob/main/docs/BROWSERS_SUPPORT.md}
+ */
+export function localDatabaseFactory(platformId, LSPrefix, IDBDBName, IDBStoreName, IDBDBVersion, IDBNoWrap) {
+    /* 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(IDBDBName, IDBStoreName, IDBDBVersion, IDBNoWrap);
+        }
+        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(LSPrefix);
+        }
+    }
+    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();
+}
+export class LocalDatabase {
+}
+LocalDatabase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: LocalDatabase, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+LocalDatabase.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: LocalDatabase, providedIn: 'root', useFactory: localDatabaseFactory, deps: [{ token: PLATFORM_ID }, { token: LS_PREFIX }, { token: IDB_DB_NAME }, { token: IDB_STORE_NAME }, { token: IDB_DB_VERSION }, { token: IDB_NO_WRAP }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: LocalDatabase, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                    useFactory: localDatabaseFactory,
+                    deps: [
+                        PLATFORM_ID,
+                        LS_PREFIX,
+                        IDB_DB_NAME,
+                        IDB_STORE_NAME,
+                        IDB_DB_VERSION,
+                        IDB_NO_WRAP,
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/lib/databases/localstorage-database.js → esm2020/lib/databases/localstorage-database.mjs}

@@ -149,9 +149,9 @@ export class LocalStorageDatabase {
         return `${this.prefix}${key}`;
     }
 }
-LocalStorageDatabase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.0-rc.0", ngImport: i0, type: LocalStorageDatabase, deps: [{ token: LS_PREFIX }], target: i0.ɵɵFactoryTarget.Injectable });
-LocalStorageDatabase.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.0.0-rc.0", ngImport: i0, type: LocalStorageDatabase, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.0-rc.0", ngImport: i0, type: LocalStorageDatabase, decorators: [{
+LocalStorageDatabase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: LocalStorageDatabase, deps: [{ token: LS_PREFIX }], target: i0.ɵɵFactoryTarget.Injectable });
+LocalStorageDatabase.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: LocalStorageDatabase, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: LocalStorageDatabase, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
@@ -160,4 +160,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.0-rc.0", ng
                     type: Inject,
                     args: [LS_PREFIX]
                 }] }]; } });
-//# 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, of, throwError, asyncScheduler } from 'rxjs';\nimport { observeOn } from 'rxjs/operators';\n\nimport { LS_PREFIX } from '../tokens';\nimport { LocalDatabase } from './local-database';\nimport { SerializationError } from './exceptions';\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  /**\n   * Constructor params are provided by Angular (but can also be passed manually in tests)\n   * @param prefix Prefix option to avoid collision for multiple apps on the same subdomain or for interoperability\n   */\n  constructor(\n    @Inject(LS_PREFIX) prefix = '',\n  ) {\n\n    /* Prefix if asked, or no prefix otherwise */\n    this.prefix = 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.substr(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"]}
+//# 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, of, throwError, asyncScheduler } from 'rxjs';\nimport { observeOn } from 'rxjs/operators';\n\nimport { LS_PREFIX } from '../tokens';\nimport { LocalDatabase } from './local-database';\nimport { SerializationError } from './exceptions';\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  /**\n   * Constructor params are provided by Angular (but can also be passed manually in tests)\n   * @param prefix Prefix option to avoid collision for multiple apps on the same subdomain or for interoperability\n   */\n  constructor(\n    @Inject(LS_PREFIX) prefix = '',\n  ) {\n\n    /* Prefix if asked, or no prefix otherwise */\n    this.prefix = 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.substr(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"]}