@esfaenza/preferences 11.2.19 → 11.2.20

package/bundles/esfaenza-preferences.umd.js

@@ -4,202 +4,6 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.esfaenza = global.esfaenza || {}, global.esfaenza.preferences = {}), global.ng.core, global.rxjs, global.rxjs.operators));
 })(this, (function (exports, core, rxjs, operators) { 'use strict';
 
-    /**
-     * Classe astratta che rappresenta lo stato di persistenza fra la libreria e uno storage
-     */
-    var BasePreferencesPersistor = /** @class */ (function () {
-        /** @ignore Costruttore */
-        function BasePreferencesPersistor(session) {
-            this.session = session;
-        }
-        /**
-         * Effettua il **persist** massivo di una lista di Chiave - Valore
-         *
-         * @param {{ [key: string]: string }} dictionary Dizionario (lista di Chiave - Valore) da persistere
-         * @param {'cache' | 'preference'} storeLevel Livello a cui storicizzare l'oggetto. Utilizzare **cache** per cose salvate dall'applicazione, utilizzare **preference** per cose salvate dall'utente
-         */
-        BasePreferencesPersistor.prototype.persistAll = function (dictionary, storeLevel) {
-            var observables = [];
-            for (var key in dictionary)
-                observables.push(this.persist(key, dictionary[key], storeLevel));
-            return rxjs.forkJoin(observables).pipe(operators.map(function (res) { return res.reduce(function (acc, val) { return acc && val; }, true); }));
-        };
-        /**
-         * Ottiene la chiave "Reale" da utilizzare per la persistenza di una chiave generica
-         *
-         * @param {string} key Chiave da storicizzare
-         *
-         * @returns {string} Unione fra l'identificativo della sessione e la chiave specificata
-         */
-        BasePreferencesPersistor.prototype.getKey = function (key) {
-            return this.session.getSessionKey() + "§" + key + "§";
-        };
-        return BasePreferencesPersistor;
-    }());
-
-    /**
-     * Indica se recuperare autonomamente tutte le configurazioni salvate al bootstrap della libreria o se aspettare le richieste specifiche.
-     *
-     * Utile se non vengono salvate tante cose, potrebbe creare un momento di irresponsività se le info da recuperare sono molte
-     */
-    var PREF_FULL_RETRIEVE_AT_START = new core.InjectionToken('PREF_FULL_RETRIEVE_AT_START');
-
-    // Angular
-    /**
-     * Service che si occupa di salvare e recuperare le preferenze utente rispetto alle chiavi salvate
-     */
-    var PreferencesService = /** @class */ (function () {
-        /**
-         * Costruttore
-         *
-         * @ignore
-         */
-        function PreferencesService(persistor, PREF_FULL_RETRIEVE_AT_START) {
-            var _this = this;
-            this.persistor = persistor;
-            this.PREF_FULL_RETRIEVE_AT_START = PREF_FULL_RETRIEVE_AT_START;
-            /**
-             * Store in memoria delle preferenze locali che sarà persistito per mezzo della classe che fa le veci del **BasePreferencesPersistor**
-             */
-            this.LocalPreferences = {};
-            /**
-             * Indica le chiavi contenute in **LocalPreferences** di che tipo sono in modo da ripulire correttamente sulla clear
-             */
-            this.LocalPreferenceType = {};
-            if (this.PREF_FULL_RETRIEVE_AT_START) {
-                // Recupero tutti gli oggetti differenziando anche lato locale fra cache e preferences
-                rxjs.forkJoin([
-                    this.persistor.recoverAll('cache').pipe(operators.take(1)),
-                    this.persistor.recoverAll('preference').pipe(operators.take(1))
-                ]).subscribe(function (res) {
-                    for (var cProp in res[0]) {
-                        _this.LocalPreferences[cProp] = res[0][cProp];
-                        _this.LocalPreferenceType[cProp] = 'cache';
-                    }
-                    for (var pProp in res[1]) {
-                        _this.LocalPreferences[pProp] = res[0][pProp];
-                        _this.LocalPreferenceType[pProp] = 'preference';
-                    }
-                });
-            }
-        }
-        /**
-         * Salva un oggetto sia nella cache locale che nel persistor
-         *
-         * @param {string} key Chiave di persistenza
-         * @param {T} item Oggetto da salvare
-         * @param {'cache' | 'preference'} storeLevel Livello a cui storicizzare l'oggetto. Utilizzare **cache** per cose salvate dall'applicazione, utilizzare **preference** per cose salvate dall'utente
-         */
-        PreferencesService.prototype.setItem = function (key, item, storeLevel) {
-            if (storeLevel === void 0) { storeLevel = 'cache'; }
-            this.setLocalItem(key, item, storeLevel);
-            return this.persist(key, item, storeLevel);
-        };
-        /**
-         * Salva un oggetto solo nella cache locale. Dovrà essere persistito manualmente o andrà perso al riavvio dell'applicazione
-         *
-         * @param {string} key Chiave di persistenza
-         * @param {T} item Oggetto da salvare
-         * @param {'cache' | 'preference'} storeLevel Livello a cui storicizzare l'oggetto. Utilizzare **cache** per cose salvate dall'applicazione, utilizzare **preference** per cose salvate dall'utente
-         */
-        PreferencesService.prototype.setLocalItem = function (key, item, storeLevel) {
-            if (storeLevel === void 0) { storeLevel = 'cache'; }
-            this.LocalPreferences[key] = item;
-            this.LocalPreferenceType[key] = storeLevel;
-            return true;
-        };
-        /**
-         * Salva, per una sessione, una chiave con un valore, viene chiamato automaticamente dal metodo **store** ma dev'essere chiamato manualmente
-         * nel caso si utilizzi il metodo **storeLocal**
-         *
-         * @param {string} key Chiave da storicizzare
-         * @param {'cache' | 'preference'} storeLevel Livello a cui storicizzare l'oggetto. Utilizzare **cache** per cose salvate dall'applicazione, utilizzare **preference** per cose salvate dall'utente
-         */
-        PreferencesService.prototype.persist = function (key, item, storeLevel) {
-            return this.persistor.persist(key, item, storeLevel);
-        };
-        /**
-         * Recupera un oggetto in base a una chiave. Permette di accedere alla copia locale o alla copia persistita.
-         *
-         * @param {string} key Chiave del valore da recuperare
-         * @param {boolean} cacheBust Indica se ignorare il valore della cache locale e recuperare l'oggetto dallo store persistito,
-         * in caso fosse stato modificato fuori sistema o da un altro sistema
-         *
-         * @returns {T} Oggetto richiesto
-         */
-        PreferencesService.prototype.getItem = function (key, cacheBust) {
-            var _this = this;
-            if (cacheBust === void 0) { cacheBust = false; }
-            if (this.LocalPreferences[key] && !cacheBust)
-                return rxjs.of(this.LocalPreferences[key]);
-            else {
-                var obj = this.persistor.recover(key);
-                if (!obj)
-                    return rxjs.of(null);
-                obj.pipe(operators.tap(function (item) { _this.LocalPreferences[key] = item; }));
-                return obj;
-            }
-        };
-        /**
-         * Recupera un oggetto in base a una chiave. Permette di accedere solo alla copia locale
-         *
-         * @param {string} key Chiave del valore da recuperare
-         *
-         * @returns {T} Oggetto richiesto
-         */
-        PreferencesService.prototype.getLocalItem = function (key) {
-            if (this.LocalPreferences[key])
-                return this.LocalPreferences[key];
-            else
-                return null;
-        };
-        /**
-         * Elimina un oggetto dalla cache sia locale che persistita
-         *
-         * @param {string} key Chiave da rimuovere
-         */
-        PreferencesService.prototype.removeItem = function (key) {
-            if (this.LocalPreferences[key]) {
-                delete this.LocalPreferences[key];
-                delete this.LocalPreferenceType[key];
-            }
-            return this.persistor.remove(key);
-        };
-        /**
-         * Ripulisce le impostazioni locali e le impostazioni salvate dal persistor
-         *
-         * @param {'cache' | 'preference'} storeLevel Livello a cui ripulire la cache. Utilizzare **cache** per cancellare cose salvate dall'applicazione, utilizzare **preference** per cancellare cose salvate dall'utente
-         */
-        PreferencesService.prototype.clear = function (storeLevel) {
-            // Pulisco la cache locale
-            for (var prop in this.LocalPreferenceType) {
-                if (this.LocalPreferenceType[prop] == storeLevel) {
-                    delete this.LocalPreferenceType[prop];
-                    delete this.LocalPreferences[prop];
-                }
-            }
-            // "Committo" le modifiche
-            return this.persistor.clear(storeLevel);
-        };
-        return PreferencesService;
-    }());
-    PreferencesService.decorators = [
-        { type: core.Injectable }
-    ];
-    PreferencesService.ctorParameters = function () { return [
-        { type: BasePreferencesPersistor },
-        { type: Boolean, decorators: [{ type: core.Optional }, { type: core.Inject, args: [PREF_FULL_RETRIEVE_AT_START,] }] }
-    ]; };
-
-    /**
-     * Classe di Configurazione per la libreria
-     */
-    var PreferencesModuleConfig = /** @class */ (function () {
-        function PreferencesModuleConfig() {
-        }
-        return PreferencesModuleConfig;
-    }());
-
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation.
 
@@ -512,6 +316,231 @@
         return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
     }
 
+    /**
+     * Indica se recuperare autonomamente tutte le configurazioni salvate al bootstrap della libreria o se aspettare le richieste specifiche.
+     *
+     * Utile se non vengono salvate tante cose, potrebbe creare un momento di irresponsività se le info da recuperare sono molte
+     */
+    var PREF_FULL_RETRIEVE_AT_START = new core.InjectionToken('PREF_FULL_RETRIEVE_AT_START');
+
+    // Angular
+    /**
+     * Service che si occupa di salvare e recuperare le preferenze utente rispetto alle chiavi salvate
+     */
+    var BaseService = /** @class */ (function () {
+        /**
+         * Costruttore
+         *
+         * @ignore
+         */
+        function BaseService(persistor, PREF_FULL_RETRIEVE_AT_START) {
+            var _this = this;
+            this.persistor = persistor;
+            this.PREF_FULL_RETRIEVE_AT_START = PREF_FULL_RETRIEVE_AT_START;
+            /** Store in memoria delle preferenze locali che sarà persistito per mezzo della classe che fa le veci del **BasePreferencesPersistor** */
+            this.LocalStore = {};
+            if (this.PREF_FULL_RETRIEVE_AT_START) {
+                this.persistor.recoverAll().pipe(operators.take(1)).subscribe(function (t) {
+                    for (var cProp in t)
+                        _this.LocalStore[cProp] = t[cProp];
+                });
+            }
+        }
+        /**
+         * Salva un oggetto sia nella cache locale che nel persistor
+         *
+         * @param {string} key Chiave di persistenza
+         * @param {T} item Oggetto da salvare
+         */
+        BaseService.prototype.setItem = function (key, item) {
+            this.setLocalItem(key, item);
+            return this.persist(key, item);
+        };
+        /**
+         * Salva un oggetto solo nella cache locale. Dovrà essere persistito manualmente o andrà perso al riavvio dell'applicazione
+         *
+         * @param {string} key Chiave di persistenza
+         * @param {T} item Oggetto da salvare
+         */
+        BaseService.prototype.setLocalItem = function (key, item) {
+            this.LocalStore[key] = item;
+            return true;
+        };
+        /**
+         * Salva, per una sessione, una chiave con un valore, viene chiamato automaticamente dal metodo **store** ma dev'essere chiamato manualmente
+         * nel caso si utilizzi il metodo **storeLocal**
+         *
+         * @param {string} key Chiave da storicizzare
+         */
+        BaseService.prototype.persist = function (key, item) {
+            return this.persistor.persist(key, item);
+        };
+        /**
+         * Recupera un oggetto in base a una chiave. Permette di accedere alla copia locale o alla copia persistita.
+         *
+         * @param {string} key Chiave del valore da recuperare
+         * @param {boolean} cacheBust Indica se ignorare il valore della cache locale e recuperare l'oggetto dallo store persistito,
+         * in caso fosse stato modificato fuori sistema o da un altro sistema
+         *
+         * @returns {T} Oggetto richiesto
+         */
+        BaseService.prototype.getItem = function (key, cacheBust) {
+            var _this = this;
+            if (cacheBust === void 0) { cacheBust = false; }
+            if (this.LocalStore[key] && !cacheBust)
+                return rxjs.of(this.LocalStore[key]);
+            else {
+                var obj = this.persistor.recover(key);
+                if (!obj)
+                    return rxjs.of(null);
+                obj.pipe(operators.tap(function (item) { _this.LocalStore[key] = item; }));
+                return obj;
+            }
+        };
+        /**
+         * Recupera un oggetto in base a una chiave. Permette di accedere solo alla copia locale
+         *
+         * @param {string} key Chiave del valore da recuperare
+         *
+         * @returns {T} Oggetto richiesto
+         */
+        BaseService.prototype.getLocalItem = function (key) {
+            if (this.LocalStore[key])
+                return this.LocalStore[key];
+            else
+                return null;
+        };
+        /**
+         * Elimina un oggetto dalla cache sia locale che persistita
+         *
+         * @param {string} key Chiave da rimuovere
+         */
+        BaseService.prototype.removeItem = function (key) {
+            if (this.LocalStore[key])
+                delete this.LocalStore[key];
+            return this.persistor.remove(key);
+        };
+        /**
+         * Ripulisce le impostazioni locali e le impostazioni salvate dal persistor
+         */
+        BaseService.prototype.clear = function () {
+            // Pulisco la cache locale
+            this.LocalStore = {};
+            // "Committo" le modifiche
+            return this.persistor.clear();
+        };
+        return BaseService;
+    }());
+    BaseService.ctorParameters = function () { return [
+        { type: undefined },
+        { type: Boolean, decorators: [{ type: core.Optional }, { type: core.Inject, args: [PREF_FULL_RETRIEVE_AT_START,] }] }
+    ]; };
+
+    /** Classe astratta che rappresenta lo stato di persistenza fra la libreria e uno storage */
+    var CachePersistor = /** @class */ (function () {
+        /** @ignore Costruttore */
+        function CachePersistor(session) {
+            this.session = session;
+        }
+        /**
+         * Effettua il **persist** massivo di una lista di Chiave - Valore
+         *
+         * @param {{ [key: string]: string }} dictionary Dizionario (lista di Chiave - Valore) da persistere
+         */
+        CachePersistor.prototype.persistAll = function (dictionary) {
+            var observables = [];
+            for (var key in dictionary)
+                observables.push(this.persist(key, dictionary[key]));
+            return rxjs.forkJoin(observables).pipe(operators.map(function (res) { return res.reduce(function (acc, val) { return acc && val; }, true); }));
+        };
+        /**
+         * Ottiene la chiave "Reale" da utilizzare per la persistenza di una chiave generica
+         *
+         * @param {string} key Chiave da storicizzare
+         *
+         * @returns {string} Unione fra l'identificativo della sessione e la chiave specificata
+         */
+        CachePersistor.prototype.getKey = function (key) {
+            return this.session.getSessionKey() + "§" + key + "§";
+        };
+        return CachePersistor;
+    }());
+
+    /** Service che si occupa di salvare e recuperare le preferenze utente rispetto alle chiavi salvate */
+    var CacheService = /** @class */ (function (_super) {
+        __extends(CacheService, _super);
+        /** @ignore Costruttore */
+        function CacheService(persistor, PREF_FULL_RETRIEVE_AT_START) {
+            return _super.call(this, persistor, PREF_FULL_RETRIEVE_AT_START) || this;
+        }
+        return CacheService;
+    }(BaseService));
+    CacheService.decorators = [
+        { type: core.Injectable }
+    ];
+    CacheService.ctorParameters = function () { return [
+        { type: CachePersistor },
+        { type: Boolean, decorators: [{ type: core.Optional }, { type: core.Inject, args: [PREF_FULL_RETRIEVE_AT_START,] }] }
+    ]; };
+
+    /**
+     * Classe astratta che rappresenta lo stato di persistenza fra la libreria e uno storage
+     */
+    var PreferencesPersistor = /** @class */ (function () {
+        /** @ignore Costruttore */
+        function PreferencesPersistor(session) {
+            this.session = session;
+        }
+        /**
+         * Effettua il **persist** massivo di una lista di Chiave - Valore
+         *
+         * @param {{ [key: string]: string }} dictionary Dizionario (lista di Chiave - Valore) da persistere
+         */
+        PreferencesPersistor.prototype.persistAll = function (dictionary) {
+            var observables = [];
+            for (var key in dictionary)
+                observables.push(this.persist(key, dictionary[key]));
+            return rxjs.forkJoin(observables).pipe(operators.map(function (res) { return res.reduce(function (acc, val) { return acc && val; }, true); }));
+        };
+        /**
+         * Ottiene la chiave "Reale" da utilizzare per la persistenza di una chiave generica
+         *
+         * @param {string} key Chiave da storicizzare
+         *
+         * @returns {string} Unione fra l'identificativo della sessione e la chiave specificata
+         */
+        PreferencesPersistor.prototype.getKey = function (key) {
+            return this.session.getSessionKey() + "§" + key + "§";
+        };
+        return PreferencesPersistor;
+    }());
+
+    /** Service che si occupa di salvare e recuperare le preferenze utente rispetto alle chiavi salvate */
+    var PreferencesService = /** @class */ (function (_super) {
+        __extends(PreferencesService, _super);
+        /** @ignore Costruttore */
+        function PreferencesService(persistor, PREF_FULL_RETRIEVE_AT_START) {
+            return _super.call(this, persistor, PREF_FULL_RETRIEVE_AT_START) || this;
+        }
+        return PreferencesService;
+    }(BaseService));
+    PreferencesService.decorators = [
+        { type: core.Injectable }
+    ];
+    PreferencesService.ctorParameters = function () { return [
+        { type: PreferencesPersistor },
+        { type: Boolean, decorators: [{ type: core.Optional }, { type: core.Inject, args: [PREF_FULL_RETRIEVE_AT_START,] }] }
+    ]; };
+
+    /**
+     * Classe di Configurazione per la libreria
+     */
+    var PreferencesModuleConfig = /** @class */ (function () {
+        function PreferencesModuleConfig() {
+        }
+        return PreferencesModuleConfig;
+    }());
+
     /**
      * Classe astratta che si occupa di recuperare l'Id sessione univoco per applicazione ed utente collegato
      */
@@ -521,30 +550,56 @@
         return BaseSessionRetriever;
     }());
 
-    /** Implementazione di default per la classe **BasePreferencesPersistor** */
-    var LocalStoragePersistor = /** @class */ (function (_super) {
-        __extends(LocalStoragePersistor, _super);
-        /** @ignore Costruttore */
-        function LocalStoragePersistor(session) {
+    /**
+     * Implementazione di default per la classe **BaseSessionRetriever**
+     */
+    var DefaultSessionRetriever = /** @class */ (function (_super) {
+        __extends(DefaultSessionRetriever, _super);
+        /**
+         * Costruttore
+         *
+         * @ignore
+         */
+        function DefaultSessionRetriever() {
+            return _super.call(this) || this;
+        }
+        /**
+         * Ottiene un ID sessione
+         *
+         * @returns {string} ID sessione
+         */
+        DefaultSessionRetriever.prototype.getSessionKey = function () {
+            return "DUMMY_SESSION";
+        };
+        return DefaultSessionRetriever;
+    }(BaseSessionRetriever));
+    DefaultSessionRetriever.decorators = [
+        { type: core.Injectable }
+    ];
+    DefaultSessionRetriever.ctorParameters = function () { return []; };
+
+    var LocalStorageCachePersistor = /** @class */ (function (_super) {
+        __extends(LocalStorageCachePersistor, _super);
+        function LocalStorageCachePersistor(session) {
             return _super.call(this, session) || this;
         }
         /** @ignore Vedi classe base */
-        LocalStoragePersistor.prototype.persist = function (key, item) {
+        LocalStorageCachePersistor.prototype.persist = function (key, item) {
             localStorage.setItem(this.getKey(key), JSON.stringify(item));
             return rxjs.of(true).pipe(operators.first());
         };
         /** @ignore Vedi classe base */
-        LocalStoragePersistor.prototype.recover = function (key) {
+        LocalStorageCachePersistor.prototype.recover = function (key) {
             var ret = JSON.parse(localStorage.getItem(this.getKey(key)));
             return rxjs.of(ret).pipe(operators.first());
         };
         /** @ignore Vedi classe base */
-        LocalStoragePersistor.prototype.remove = function (key) {
+        LocalStorageCachePersistor.prototype.remove = function (key) {
             var ret = localStorage.removeItem(this.getKey(key));
             return rxjs.of(true).pipe(operators.first());
         };
         /** @ignore Vedi classe base */
-        LocalStoragePersistor.prototype.recoverAll = function () {
+        LocalStorageCachePersistor.prototype.recoverAll = function () {
             var ret = {};
             for (var k in localStorage) {
                 if (k.includes("§") && k.startsWith(this.session.getSessionKey()))
@@ -553,49 +608,67 @@
             return rxjs.of(ret).pipe(operators.first());
         };
         /** @ignore Vedi classe base */
-        LocalStoragePersistor.prototype.clear = function () {
+        LocalStorageCachePersistor.prototype.clear = function () {
             for (var k in localStorage) {
                 if (k.includes("§") && k.startsWith(this.session.getSessionKey()))
                     localStorage.removeItem(k);
             }
             return rxjs.of(true).pipe(operators.first());
         };
-        return LocalStoragePersistor;
-    }(BasePreferencesPersistor));
-    LocalStoragePersistor.decorators = [
+        return LocalStorageCachePersistor;
+    }(CachePersistor));
+    LocalStorageCachePersistor.decorators = [
         { type: core.Injectable }
     ];
-    LocalStoragePersistor.ctorParameters = function () { return [
+    LocalStorageCachePersistor.ctorParameters = function () { return [
         { type: BaseSessionRetriever }
     ]; };
 
-    /**
-     * Implementazione di default per la classe **BaseSessionRetriever**
-     */
-    var DefaultSessionRetriever = /** @class */ (function (_super) {
-        __extends(DefaultSessionRetriever, _super);
-        /**
-         * Costruttore
-         *
-         * @ignore
-         */
-        function DefaultSessionRetriever() {
-            return _super.call(this) || this;
+    var LocalStoragePreferencesPersistor = /** @class */ (function (_super) {
+        __extends(LocalStoragePreferencesPersistor, _super);
+        function LocalStoragePreferencesPersistor(session) {
+            return _super.call(this, session) || this;
         }
-        /**
-         * Ottiene un ID sessione
-         *
-         * @returns {string} ID sessione
-         */
-        DefaultSessionRetriever.prototype.getSessionKey = function () {
-            return "DUMMY_SESSION";
+        /** @ignore Vedi classe base */
+        LocalStoragePreferencesPersistor.prototype.persist = function (key, item) {
+            localStorage.setItem(this.getKey(key), JSON.stringify(item));
+            return rxjs.of(true).pipe(operators.first());
         };
-        return DefaultSessionRetriever;
-    }(BaseSessionRetriever));
-    DefaultSessionRetriever.decorators = [
+        /** @ignore Vedi classe base */
+        LocalStoragePreferencesPersistor.prototype.recover = function (key) {
+            var ret = JSON.parse(localStorage.getItem(this.getKey(key)));
+            return rxjs.of(ret).pipe(operators.first());
+        };
+        /** @ignore Vedi classe base */
+        LocalStoragePreferencesPersistor.prototype.remove = function (key) {
+            var ret = localStorage.removeItem(this.getKey(key));
+            return rxjs.of(true).pipe(operators.first());
+        };
+        /** @ignore Vedi classe base */
+        LocalStoragePreferencesPersistor.prototype.recoverAll = function () {
+            var ret = {};
+            for (var k in localStorage) {
+                if (k.includes("§") && k.startsWith(this.session.getSessionKey()))
+                    ret[k.match(/§(.*)§/)[1]] = JSON.parse(localStorage.getItem(k));
+            }
+            return rxjs.of(ret).pipe(operators.first());
+        };
+        /** @ignore Vedi classe base */
+        LocalStoragePreferencesPersistor.prototype.clear = function () {
+            for (var k in localStorage) {
+                if (k.includes("§") && k.startsWith(this.session.getSessionKey()))
+                    localStorage.removeItem(k);
+            }
+            return rxjs.of(true).pipe(operators.first());
+        };
+        return LocalStoragePreferencesPersistor;
+    }(PreferencesPersistor));
+    LocalStoragePreferencesPersistor.decorators = [
         { type: core.Injectable }
     ];
-    DefaultSessionRetriever.ctorParameters = function () { return []; };
+    LocalStoragePreferencesPersistor.ctorParameters = function () { return [
+        { type: BaseSessionRetriever }
+    ]; };
 
     var PreferencesModule = /** @class */ (function () {
         function PreferencesModule() {
@@ -604,8 +677,10 @@
             return {
                 ngModule: PreferencesModule,
                 providers: [
+                    CacheService,
                     PreferencesService,
-                    { provide: BasePreferencesPersistor, useClass: (config === null || config === void 0 ? void 0 : config.preferencePersistor) || LocalStoragePersistor },
+                    { provide: PreferencesPersistor, useClass: (config === null || config === void 0 ? void 0 : config.preferencePersistor) || LocalStoragePreferencesPersistor },
+                    { provide: CachePersistor, useClass: (config === null || config === void 0 ? void 0 : config.cachePersistor) || LocalStorageCachePersistor },
                     { provide: BaseSessionRetriever, useClass: (config === null || config === void 0 ? void 0 : config.sessionRetriever) || DefaultSessionRetriever },
                     { provide: PREF_FULL_RETRIEVE_AT_START, useValue: (config === null || config === void 0 ? void 0 : config.retrieveAllAtStart) || true }
                 ]
@@ -621,14 +696,18 @@
      * Generated bundle index. Do not edit.
      */
 
-    exports.BasePreferencesPersistor = BasePreferencesPersistor;
     exports.BaseSessionRetriever = BaseSessionRetriever;
+    exports.CachePersistor = CachePersistor;
+    exports.CacheService = CacheService;
     exports.PREF_FULL_RETRIEVE_AT_START = PREF_FULL_RETRIEVE_AT_START;
     exports.PreferencesModule = PreferencesModule;
     exports.PreferencesModuleConfig = PreferencesModuleConfig;
+    exports.PreferencesPersistor = PreferencesPersistor;
     exports.PreferencesService = PreferencesService;
-    exports["ɵa"] = LocalStoragePersistor;
-    exports["ɵb"] = DefaultSessionRetriever;
+    exports["ɵa"] = BaseService;
+    exports["ɵc"] = LocalStoragePreferencesPersistor;
+    exports["ɵd"] = LocalStorageCachePersistor;
+    exports["ɵe"] = DefaultSessionRetriever;
 
     Object.defineProperty(exports, '__esModule', { value: true });