@esfaenza/preferences 16.2.29 → 17.3.15

package/fesm2022/esfaenza-preferences.mjs

@@ -4,417 +4,417 @@ import { __decorate, __param } from 'tslib';
 import { of, forkJoin } from 'rxjs';
 import { take, tap, switchMap, map, first } from 'rxjs/operators';
 
-/**
- * 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
- */
-const PREF_FULL_RETRIEVE_AT_START = new InjectionToken('PREF_FULL_RETRIEVE_AT_START');
-/** Modalità di Debug */
+/**
+ * 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
+ */
+const PREF_FULL_RETRIEVE_AT_START = new InjectionToken('PREF_FULL_RETRIEVE_AT_START');
+/** Modalità di Debug */
 const PREF_DEBUG_MODE = new InjectionToken('PREF_DEBUG_MODE');
 
-/**
- * Service che si occupa di salvare e recuperare le preferenze utente rispetto alle chiavi salvate
- */
-let BaseService = class BaseService {
-    persistor;
-    PREF_FULL_RETRIEVE_AT_START;
-    /** Store in memoria delle preferenze locali che sarà persistito per mezzo della classe che fa le veci del **BasePreferencesPersistor** */
-    LocalStore = {};
-    /** Indica se ho già effettuato il retrieve di tutta la roba salvata */
-    AllRetrieved = false;
-    /**
-     * Costruttore
-     *
-     * @ignore
-     */
-    constructor(persistor, PREF_FULL_RETRIEVE_AT_START) {
-        this.persistor = persistor;
-        this.PREF_FULL_RETRIEVE_AT_START = PREF_FULL_RETRIEVE_AT_START;
-    }
-    /**
-     * Salva un oggetto sia nella cache locale che nel persistor
-     *
-     * @param {string} key Chiave di persistenza
-     * @param {T} item Oggetto da salvare
-     */
-    setItem(key, item) {
-        let detatched = JSON.parse(JSON.stringify(item));
-        if (detatched) {
-            if (detatched.selfsearch)
-                detatched.selfsearch = false;
-            if (detatched.page && detatched.items && detatched.items.length > 0)
-                detatched.items = [];
-        }
-        this.setLocalItem(key, detatched);
-        return this.persist(key, detatched);
-    }
-    /**
-     * 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
-     */
-    setLocalItem(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
-     */
-    persist(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 {Observable<T>} Oggetto richiesto
-     */
-    getItem(key, cacheBust = false) {
-        if (this.PREF_FULL_RETRIEVE_AT_START && !this.AllRetrieved) {
-            let retrieveObservable = this.persistor.recoverAll().pipe(take(1), tap(t => {
-                this.AllRetrieved = true;
-                for (let cProp in t)
-                    this.LocalStore[cProp] = t[cProp];
-            }));
-            return retrieveObservable.pipe(switchMap(r => this.doGetItem(key, cacheBust)));
-        }
-        return this.doGetItem(key, cacheBust);
-    }
-    /**
-     * Funzione interna che effettivamente recupera le cache
-     *
-     * @param key Chiave da recuperare
-     * @param cacheBust Indica se raccogliere dagli elementi locali o se prendere una copia nuova dell'oggetto dalla cache persistita
-     *
-     * @returns Observable che alla sottoscrizione restituisce l'oggetto richiesto
-     */
-    doGetItem(key, cacheBust = false) {
-        if (this.LocalStore[key] && !cacheBust)
-            return of(this.LocalStore[key]);
-        else {
-            var obj = this.persistor.recover(key);
-            if (!obj)
-                return of(null);
-            obj.pipe(tap(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
-     */
-    getLocalItem(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
-     */
-    removeItem(key) {
-        if (this.LocalStore[key])
-            delete this.LocalStore[key];
-        return this.persistor.remove(key);
-    }
-    /**
-     * Ripulisce le impostazioni locali e le impostazioni salvate dal persistor
-     */
-    clear() {
-        // Pulisco la cache locale
-        this.LocalStore = {};
-        // "Committo" le modifiche
-        return this.persistor.clear();
-    }
-};
-BaseService = __decorate([
-    __param(1, Optional()),
-    __param(1, Inject(PREF_FULL_RETRIEVE_AT_START))
+/**
+ * Service che si occupa di salvare e recuperare le preferenze utente rispetto alle chiavi salvate
+ */
+let BaseService = class BaseService {
+    persistor;
+    PREF_FULL_RETRIEVE_AT_START;
+    /** Store in memoria delle preferenze locali che sarà persistito per mezzo della classe che fa le veci del **BasePreferencesPersistor** */
+    LocalStore = {};
+    /** Indica se ho già effettuato il retrieve di tutta la roba salvata */
+    AllRetrieved = false;
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(persistor, PREF_FULL_RETRIEVE_AT_START) {
+        this.persistor = persistor;
+        this.PREF_FULL_RETRIEVE_AT_START = PREF_FULL_RETRIEVE_AT_START;
+    }
+    /**
+     * Salva un oggetto sia nella cache locale che nel persistor
+     *
+     * @param {string} key Chiave di persistenza
+     * @param {T} item Oggetto da salvare
+     */
+    setItem(key, item) {
+        let detatched = JSON.parse(JSON.stringify(item));
+        if (detatched) {
+            if (detatched.selfsearch)
+                detatched.selfsearch = false;
+            if (detatched.page && detatched.items && detatched.items.length > 0)
+                detatched.items = [];
+        }
+        this.setLocalItem(key, detatched);
+        return this.persist(key, detatched);
+    }
+    /**
+     * 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
+     */
+    setLocalItem(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
+     */
+    persist(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 {Observable<T>} Oggetto richiesto
+     */
+    getItem(key, cacheBust = false) {
+        if (this.PREF_FULL_RETRIEVE_AT_START && !this.AllRetrieved) {
+            let retrieveObservable = this.persistor.recoverAll().pipe(take(1), tap(t => {
+                this.AllRetrieved = true;
+                for (let cProp in t)
+                    this.LocalStore[cProp] = t[cProp];
+            }));
+            return retrieveObservable.pipe(switchMap(r => this.doGetItem(key, cacheBust)));
+        }
+        return this.doGetItem(key, cacheBust);
+    }
+    /**
+     * Funzione interna che effettivamente recupera le cache
+     *
+     * @param key Chiave da recuperare
+     * @param cacheBust Indica se raccogliere dagli elementi locali o se prendere una copia nuova dell'oggetto dalla cache persistita
+     *
+     * @returns Observable che alla sottoscrizione restituisce l'oggetto richiesto
+     */
+    doGetItem(key, cacheBust = false) {
+        if (this.LocalStore[key] && !cacheBust)
+            return of(this.LocalStore[key]);
+        else {
+            var obj = this.persistor.recover(key);
+            if (!obj)
+                return of(null);
+            obj.pipe(tap(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
+     */
+    getLocalItem(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
+     */
+    removeItem(key) {
+        if (this.LocalStore[key])
+            delete this.LocalStore[key];
+        return this.persistor.remove(key);
+    }
+    /**
+     * Ripulisce le impostazioni locali e le impostazioni salvate dal persistor
+     */
+    clear() {
+        // Pulisco la cache locale
+        this.LocalStore = {};
+        // "Committo" le modifiche
+        return this.persistor.clear();
+    }
+};
+BaseService = __decorate([
+    __param(1, Optional()),
+    __param(1, Inject(PREF_FULL_RETRIEVE_AT_START))
 ], BaseService);
 
-/** Classe astratta che rappresenta lo stato di persistenza fra la libreria e uno storage */
-class CachePersistor {
-    session;
-    /** @ignore Costruttore */
-    constructor(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
-     */
-    persistAll(dictionary) {
-        let observables = [];
-        for (let key in dictionary)
-            observables.push(this.persist(key, dictionary[key]));
-        return forkJoin(observables).pipe(map(res => res.reduce((acc, val) => 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
-     */
-    getKey(key) {
-        return this.session.getSessionKey() + "§" + key + "§";
-    }
+/** Classe astratta che rappresenta lo stato di persistenza fra la libreria e uno storage */
+class CachePersistor {
+    session;
+    /** @ignore Costruttore */
+    constructor(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
+     */
+    persistAll(dictionary) {
+        let observables = [];
+        for (let key in dictionary)
+            observables.push(this.persist(key, dictionary[key]));
+        return forkJoin(observables).pipe(map(res => res.reduce((acc, val) => 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
+     */
+    getKey(key) {
+        return this.session.getSessionKey() + "§" + key + "§";
+    }
 }
 
-// Angular
-/** Service che si occupa di salvare e recuperare le preferenze utente rispetto alle chiavi salvate */
-class CacheService extends BaseService {
-    /** @ignore Costruttore */
-    constructor(persistor, PREF_FULL_RETRIEVE_AT_START) {
-        super(persistor, PREF_FULL_RETRIEVE_AT_START);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CacheService, deps: [{ token: CachePersistor }, { token: PREF_FULL_RETRIEVE_AT_START, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CacheService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CacheService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: CachePersistor }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [PREF_FULL_RETRIEVE_AT_START]
-                }] }]; } });
+// Angular
+/** Service che si occupa di salvare e recuperare le preferenze utente rispetto alle chiavi salvate */
+class CacheService extends BaseService {
+    /** @ignore Costruttore */
+    constructor(persistor, PREF_FULL_RETRIEVE_AT_START) {
+        super(persistor, PREF_FULL_RETRIEVE_AT_START);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CacheService, deps: [{ token: CachePersistor }, { token: PREF_FULL_RETRIEVE_AT_START, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CacheService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CacheService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: CachePersistor }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [PREF_FULL_RETRIEVE_AT_START]
+                }] }] });
 
-/**
- * Classe astratta che rappresenta lo stato di persistenza fra la libreria e uno storage
- */
-class PreferencesPersistor {
-    session;
-    /** @ignore Costruttore */
-    constructor(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
-     */
-    persistAll(dictionary) {
-        let observables = [];
-        for (let key in dictionary)
-            observables.push(this.persist(key, dictionary[key]));
-        return forkJoin(observables).pipe(map(res => res.reduce((acc, val) => 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
-     */
-    getKey(key) {
-        return this.session.getSessionKey() + "§" + key + "§";
-    }
+/**
+ * Classe astratta che rappresenta lo stato di persistenza fra la libreria e uno storage
+ */
+class PreferencesPersistor {
+    session;
+    /** @ignore Costruttore */
+    constructor(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
+     */
+    persistAll(dictionary) {
+        let observables = [];
+        for (let key in dictionary)
+            observables.push(this.persist(key, dictionary[key]));
+        return forkJoin(observables).pipe(map(res => res.reduce((acc, val) => 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
+     */
+    getKey(key) {
+        return this.session.getSessionKey() + "§" + key + "§";
+    }
 }
 
-// Angular
-/** Service che si occupa di salvare e recuperare le preferenze utente rispetto alle chiavi salvate */
-class PreferencesService extends BaseService {
-    /** @ignore Costruttore */
-    constructor(persistor, PREF_FULL_RETRIEVE_AT_START) {
-        super(persistor, PREF_FULL_RETRIEVE_AT_START);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PreferencesService, deps: [{ token: PreferencesPersistor }, { token: PREF_FULL_RETRIEVE_AT_START, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PreferencesService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PreferencesService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: PreferencesPersistor }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [PREF_FULL_RETRIEVE_AT_START]
-                }] }]; } });
+// Angular
+/** Service che si occupa di salvare e recuperare le preferenze utente rispetto alle chiavi salvate */
+class PreferencesService extends BaseService {
+    /** @ignore Costruttore */
+    constructor(persistor, PREF_FULL_RETRIEVE_AT_START) {
+        super(persistor, PREF_FULL_RETRIEVE_AT_START);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PreferencesService, deps: [{ token: PreferencesPersistor }, { token: PREF_FULL_RETRIEVE_AT_START, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PreferencesService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PreferencesService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: PreferencesPersistor }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [PREF_FULL_RETRIEVE_AT_START]
+                }] }] });
 
-/**
- * Classe di Configurazione per la libreria
- */
-class PreferencesModuleConfig {
-    /**
-     * 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
-     */
-    retrieveAllAtStart;
-    /**
-     * Classe che si deve occupare dello store "Definitivo" delle preferenze. Di default viene proposto uno store lato localStorage ma si può facilmente
-     * fornire uno storage che porta le informazioni lato Database
-     */
-    preferencePersistor;
-    /**
-    * Classe che si deve occupare dello store "Definitivo" delle cache. Di default viene proposto uno store lato localStorage ma si può facilmente
-    * fornire uno storage che porta le informazioni lato Database
-    */
-    cachePersistor;
-    /** Classe che si deve occupare per generare un ID univoco di sessione in base al quale verranno salvate le preferenze */
-    sessionRetriever;
-    /** Attiva la modalità di debug per l'esposizione di messaggi significativi */
-    debugMode;
+/**
+ * Classe di Configurazione per la libreria
+ */
+class PreferencesModuleConfig {
+    /**
+     * 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
+     */
+    retrieveAllAtStart;
+    /**
+     * Classe che si deve occupare dello store "Definitivo" delle preferenze. Di default viene proposto uno store lato localStorage ma si può facilmente
+     * fornire uno storage che porta le informazioni lato Database
+     */
+    preferencePersistor;
+    /**
+    * Classe che si deve occupare dello store "Definitivo" delle cache. Di default viene proposto uno store lato localStorage ma si può facilmente
+    * fornire uno storage che porta le informazioni lato Database
+    */
+    cachePersistor;
+    /** Classe che si deve occupare per generare un ID univoco di sessione in base al quale verranno salvate le preferenze */
+    sessionRetriever;
+    /** Attiva la modalità di debug per l'esposizione di messaggi significativi */
+    debugMode;
 }
 
-/**
- * Classe astratta che si occupa di recuperare l'Id sessione univoco per applicazione ed utente collegato
- */
-class BaseSessionRetriever {
+/**
+ * Classe astratta che si occupa di recuperare l'Id sessione univoco per applicazione ed utente collegato
+ */
+class BaseSessionRetriever {
 }
 
-/**
- * Implementazione di default per la classe **BaseSessionRetriever**
- */
-class DefaultSessionRetriever extends BaseSessionRetriever {
-    /**
-     * Costruttore
-     *
-     * @ignore
-     */
-    constructor() { super(); }
-    /**
-     * Ottiene un ID sessione
-     *
-     * @returns {string} ID sessione
-     */
-    getSessionKey() {
-        return "DUMMY_SESSION";
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DefaultSessionRetriever, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DefaultSessionRetriever });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DefaultSessionRetriever, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return []; } });
+/**
+ * Implementazione di default per la classe **BaseSessionRetriever**
+ */
+class DefaultSessionRetriever extends BaseSessionRetriever {
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor() { super(); }
+    /**
+     * Ottiene un ID sessione
+     *
+     * @returns {string} ID sessione
+     */
+    getSessionKey() {
+        return "DUMMY_SESSION";
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DefaultSessionRetriever, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DefaultSessionRetriever });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DefaultSessionRetriever, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
 
-// Angular
-class LocalStorageCachePersistor extends CachePersistor {
-    constructor(session) {
-        super(session);
-    }
-    /** @ignore Vedi classe base */
-    persist(key, item) {
-        localStorage.setItem(this.getKey(key), JSON.stringify(item));
-        return of(true).pipe(first());
-    }
-    /** @ignore Vedi classe base */
-    recover(key) {
-        var ret = JSON.parse(localStorage.getItem(this.getKey(key)));
-        return of(ret).pipe(first());
-    }
-    /** @ignore Vedi classe base */
-    remove(key) {
-        var ret = localStorage.removeItem(this.getKey(key));
-        return of(true).pipe(first());
-    }
-    /** @ignore Vedi classe base */
-    recoverAll() {
-        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 of(ret).pipe(first());
-    }
-    /** @ignore Vedi classe base */
-    clear() {
-        for (var k in localStorage) {
-            if (k.includes("§") && k.startsWith(this.session.getSessionKey()))
-                localStorage.removeItem(k);
-        }
-        return of(true).pipe(first());
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalStorageCachePersistor, deps: [{ token: BaseSessionRetriever }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalStorageCachePersistor });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalStorageCachePersistor, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: BaseSessionRetriever }]; } });
+// Angular
+class LocalStorageCachePersistor extends CachePersistor {
+    constructor(session) {
+        super(session);
+    }
+    /** @ignore Vedi classe base */
+    persist(key, item) {
+        localStorage.setItem(this.getKey(key), JSON.stringify(item));
+        return of(true).pipe(first());
+    }
+    /** @ignore Vedi classe base */
+    recover(key) {
+        var ret = JSON.parse(localStorage.getItem(this.getKey(key)));
+        return of(ret).pipe(first());
+    }
+    /** @ignore Vedi classe base */
+    remove(key) {
+        var ret = localStorage.removeItem(this.getKey(key));
+        return of(true).pipe(first());
+    }
+    /** @ignore Vedi classe base */
+    recoverAll() {
+        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 of(ret).pipe(first());
+    }
+    /** @ignore Vedi classe base */
+    clear() {
+        for (var k in localStorage) {
+            if (k.includes("§") && k.startsWith(this.session.getSessionKey()))
+                localStorage.removeItem(k);
+        }
+        return of(true).pipe(first());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageCachePersistor, deps: [{ token: BaseSessionRetriever }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageCachePersistor });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStorageCachePersistor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: BaseSessionRetriever }] });
 
-// Angular
-class LocalStoragePreferencesPersistor extends PreferencesPersistor {
-    constructor(session) {
-        super(session);
-    }
-    /** @ignore Vedi classe base */
-    persist(key, item) {
-        localStorage.setItem(this.getKey(key), JSON.stringify(item));
-        return of(true).pipe(first());
-    }
-    /** @ignore Vedi classe base */
-    recover(key) {
-        var ret = JSON.parse(localStorage.getItem(this.getKey(key)));
-        return of(ret).pipe(first());
-    }
-    /** @ignore Vedi classe base */
-    remove(key) {
-        var ret = localStorage.removeItem(this.getKey(key));
-        return of(true).pipe(first());
-    }
-    /** @ignore Vedi classe base */
-    recoverAll() {
-        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 of(ret).pipe(first());
-    }
-    /** @ignore Vedi classe base */
-    clear() {
-        for (var k in localStorage) {
-            if (k.includes("§") && k.startsWith(this.session.getSessionKey()))
-                localStorage.removeItem(k);
-        }
-        return of(true).pipe(first());
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalStoragePreferencesPersistor, deps: [{ token: BaseSessionRetriever }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalStoragePreferencesPersistor });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LocalStoragePreferencesPersistor, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: BaseSessionRetriever }]; } });
+// Angular
+class LocalStoragePreferencesPersistor extends PreferencesPersistor {
+    constructor(session) {
+        super(session);
+    }
+    /** @ignore Vedi classe base */
+    persist(key, item) {
+        localStorage.setItem(this.getKey(key), JSON.stringify(item));
+        return of(true).pipe(first());
+    }
+    /** @ignore Vedi classe base */
+    recover(key) {
+        var ret = JSON.parse(localStorage.getItem(this.getKey(key)));
+        return of(ret).pipe(first());
+    }
+    /** @ignore Vedi classe base */
+    remove(key) {
+        var ret = localStorage.removeItem(this.getKey(key));
+        return of(true).pipe(first());
+    }
+    /** @ignore Vedi classe base */
+    recoverAll() {
+        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 of(ret).pipe(first());
+    }
+    /** @ignore Vedi classe base */
+    clear() {
+        for (var k in localStorage) {
+            if (k.includes("§") && k.startsWith(this.session.getSessionKey()))
+                localStorage.removeItem(k);
+        }
+        return of(true).pipe(first());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStoragePreferencesPersistor, deps: [{ token: BaseSessionRetriever }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStoragePreferencesPersistor });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LocalStoragePreferencesPersistor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: BaseSessionRetriever }] });
 
-class PreferencesModule {
-    static forRoot(config) {
-        return {
-            ngModule: PreferencesModule,
-            providers: [
-                CacheService,
-                PreferencesService,
-                { provide: PreferencesPersistor, useClass: config?.preferencePersistor || LocalStoragePreferencesPersistor },
-                { provide: CachePersistor, useClass: config?.cachePersistor || LocalStorageCachePersistor },
-                { provide: BaseSessionRetriever, useClass: config?.sessionRetriever || DefaultSessionRetriever },
-                { provide: PREF_FULL_RETRIEVE_AT_START, useValue: config?.retrieveAllAtStart || true },
-                { provide: PREF_DEBUG_MODE, useValue: config?.debugMode || false },
-            ]
-        };
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PreferencesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: PreferencesModule });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PreferencesModule });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PreferencesModule, decorators: [{
-            type: NgModule
+class PreferencesModule {
+    static forRoot(config) {
+        return {
+            ngModule: PreferencesModule,
+            providers: [
+                CacheService,
+                PreferencesService,
+                { provide: PreferencesPersistor, useClass: config?.preferencePersistor || LocalStoragePreferencesPersistor },
+                { provide: CachePersistor, useClass: config?.cachePersistor || LocalStorageCachePersistor },
+                { provide: BaseSessionRetriever, useClass: config?.sessionRetriever || DefaultSessionRetriever },
+                { provide: PREF_FULL_RETRIEVE_AT_START, useValue: config?.retrieveAllAtStart || true },
+                { provide: PREF_DEBUG_MODE, useValue: config?.debugMode || false },
+            ]
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PreferencesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: PreferencesModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PreferencesModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PreferencesModule, decorators: [{
+            type: NgModule
         }] });
 
-/**
- * Generated bundle index. Do not edit.
+/**
+ * Generated bundle index. Do not edit.
  */
 
 export { BaseSessionRetriever, CachePersistor, CacheService, LocalStorageCachePersistor, LocalStoragePreferencesPersistor, PREF_DEBUG_MODE, PREF_FULL_RETRIEVE_AT_START, PreferencesModule, PreferencesModuleConfig, PreferencesPersistor, PreferencesService };