@esfaenza/localizations 11.2.9 → 11.2.11

package/fesm2015/esfaenza-localizations.js

@@ -1,11 +1,10 @@
-import { InjectionToken, Injectable, Inject, Pipe, Optional, NgModule } from '@angular/core';
+import { __awaiter } from 'tslib';
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, Inject, Pipe, Optional, Injector, NgModule } from '@angular/core';
+import { take, first } from 'rxjs/operators';
+import { ReplaySubject, of } from 'rxjs';
 import { DateService } from '@esfaenza/extensions';
 
-/**
- * Locale da utilizzare per le traduzioni
- */
-const LOC_LOCALE = new InjectionToken('LOC_LOCALE');
-
 /**
  * Contenitore delle localizzazioni collegate ad un testo "base", una per ogni linguaggio supportato
  */
@@ -73,12 +72,6 @@ LocaleDefinitions.AvailableLocales = [
     new LocaleObject('en-US', 'English', ['en', 'en-US'])
 ];
 
-/**
- * Classe di configurazione per il modulo di localizzazione
- */
-class LocalizationModuleConfig {
-}
-
 /**
  * Classe che rappresenta la localizzazione di un test base per una certa lingua
  */
@@ -95,77 +88,13 @@ class SpecializedLocalization {
     }
 }
 
-/**
- * Classe singleton che contiene le traduzioni di base (per evitare di ripeterle in oggi classe di traduzione) e le funzioni base per
- * inserire e leggere traduzioni in/da una cache
- */
-class BaseLocalization {
-    /**
-     * Costruttore. Da qui utilizzando il metodo statico **BaseLocalization.set** si va a popolare la cache delle traduzioni **BaseTranslations**
-     */
-    constructor() {
-        /**
-         * Cache di tutte le localizzazioni di base
-         */
-        this.BaseTranslations = {};
-        // Odio sprecare caratteri... soprattutto quando rischio che non vengano minificati
-        let bt = this.BaseTranslations;
-        let bl = BaseLocalization;
-        bl.set(bt, "en->it", "Remove", ["Elimina"]);
-        bl.set(bt, "en->it", "Paging", ["Paginazione"]);
-        bl.set(bt, "en->it", "Yes", ["Si"]);
-        bl.set(bt, "en->it", "No", ["No"]);
-        bl.set(bt, "en->it", "YES", ["SI'"]);
-        bl.set(bt, "en->it", "NO", ["NO"]);
-        bl.set(bt, "en->it", "Found objects", ["Risultati trovati"]);
-        bl.set(bt, "en->it", "Loading data...", ["Carico i dati..."]);
-        bl.set(bt, "en->it", "Error during save operations", ["Errori durante il salvataggio"]);
-        bl.set(bt, "en->it", "Error", ["Errore"]);
-        bl.set(bt, "en->it", "Warning", ["Avviso"]);
-        bl.set(bt, "en->it", "Information", ["Informazione"]);
-        bl.set(bt, "en->it", "Save", ["Salva"]);
-        bl.set(bt, "en->it", "Back", ["Indietro"]);
-        bl.set(bt, "en->it", "From", ["Da"]);
-        bl.set(bt, "en->it", "To", ["A"]);
-        bl.set(bt, "en->it", "View Chart", ["Vedi Grafico"]);
-        bl.set(bt, "en->it", "View Table", ["Vedi Tabella"]);
-        bl.set(bt, "en->it", "Notes", ["Note"]);
-        bl.set(bt, "en->it", "Edit Notes", ["Modifica Note"]);
-        bl.set(bt, "en->it", "Cancel", ["Annulla"]);
-        bl.set(bt, "en->it", "Confirm", ["Conferma"]);
-        bl.set(bt, "en->it", "View", ["Visualizza"]);
-        bl.set(bt, "en->it", "Close", ["Chiudi"]);
-        bl.set(bt, "en->it", "Select", ["Seleziona"]);
-        bl.set(bt, "en->it", "Meter Reading registered successfully", ["Lettura registrata correttamente"]);
-        bl.set(bt, "en->it", "Validation errors during save operations", ["Errori di validazione durante il salvataggio"]);
-        bl.set(bt, "en->it", "Can't register reading", ["Impossibile registrare la lettura"]);
-        bl.set(bt, "en->it", "Electricity", ["Elettricita"]);
-        bl.set(bt, "en->it", "Gas", ["Gas"]);
-        bl.set(bt, "en->it", "Water", ["Acqua"]);
-        bl.set(bt, "en->it", "Delete", ["Elimina"]);
-        bl.set(bt, "en->it", "This operation cannot be reverted", ["Questa operazione non puo' essere annullata"]);
-        bl.set(bt, "en->it", "Hide", ["Nascondi"]);
-        // Helper validazione
-        bl.set(bt, "en->it", "Required field", ["Campo richiesto"]);
-        bl.set(bt, "en->it", "Wrong field format", ["Formato campo errato"]);
-        bl.set(bt, "en->it", "Wrong field format or field missing", ["Formato campo errato o campo mancante"]);
-        bl.set(bt, "en->it", "You don't have the required permissions to view this page. The navigation has been blocked", ["Non si hanno privilegi a sufficienza per accedere a questa pagina. La navigazione e' stata bloccata"]);
-        // Informazioni sulle date
-        bl.setToken(bt, "en->it", "getDateMonthPosition", "0", ["1"]);
-        bl.setToken(bt, "en->it", "getDisplayDateMonthPosition", "1", ["1"]);
-        bl.setToken(bt, "en->it", "getLocale", "en-US", ["it-IT"]);
-        bl.setToken(bt, "en->it", "getSmallDateFormat", "MM/DD/YYYY", ["DD/MM/YYYY"]);
-        bl.setToken(bt, "en->it", "getDefaultDateFormat", "MM/DD/YYYY", ["MM/DD/YYYY"]);
-        bl.setToken(bt, "en->it", "getSmallDateDisplayFormat", "DD/MM/YYYY", ["DD/MM/YYYY"]);
-        bl.setToken(bt, "en->it", "getFullDateFormat", "MM/DD/YYYY HH:mm:ss", ["DD/MM/YYYY HH:mm:ss"]);
-        bl.setToken(bt, "en->it", "getFullDateDisplayFormat", "DD/MM/YYYY HH:mm:ss", ["DD/MM/YYYY HH:mm:ss"]);
-        bl.setToken(bt, "en->it", "getFullDateFormatNoSeconds", "MM/DD/YYYY HH:mm", ["DD/MM/YYYY HH:mm"]);
-        bl.setToken(bt, "en->it", "getFullDateDisplayFormatNoSeconds", "DD/MM/YYYY HH:mm", ["DD/MM/YYYY HH:mm"]);
+class LocalizationPersistor {
+    constructor(LocCache = null) {
+        this.LocCache = LocCache;
     }
     /**
      * Imposta la localizzazione di un token all'interno della cache scelta
      *
-     * @param {{ [id: string]: ItemLocalization }} locCache Cache all'interno della quale inserire l'informazione del token con le localizzazioni
      * @param {string} direction Direzione della traduzione, rappresenta la lingua base in cui aspettarsi il testo e le varie lingue in cui viene tradotta.
      * Ad esempio, "en->it" indica che il parametro **left** è valido per le localizzazioni in inglese, mentre nell'elemento 0 del parametro **right**
      * è presente l'unica traduzione in italiano, per definire più traduzioni sul lato destro della freccia bisogna concatenarle con la virgola, ad esempio "en->it,jp,ecc"
@@ -173,56 +102,54 @@ class BaseLocalization {
      * @param {string} left Valore del token per la lingua specificata nel lato immediatamente sinistro alla freccia del parametro **direction**
      * @param {string} right Array con i valori facenti riferimento all'N-esima lingua del lato destro del parametro **direction**
      */
-    static setToken(locCache, direction, token, left, right) {
+    setToken(direction, token, left, right) {
         let parsingRegex = /([a-zA-Z]+)[\s]*->[\s]*([a-zA-Z,\s]+)+/g;
         var parsingRes = parsingRegex.exec(direction);
         let from = parsingRes[1];
         let to = parsingRes[2].replace(/\s/g, '').split(',');
         let localeFrom = LocaleDefinitions.getByAlias(from);
-        BaseLocalization._set(locCache, token, localeFrom.id, left, true);
+        this._set(token, localeFrom.id, left, true);
         to.forEach((t, index) => {
             let localeTo = LocaleDefinitions.getByAlias(t);
-            BaseLocalization._set(locCache, token, localeTo.id, right[index], true);
+            this._set(token, localeTo.id, right[index], true);
         });
     }
     /**
      * Imposta la localizzazione di una frase all'interno della cache scelta
      *
-     * @param {{ [id: string]: ItemLocalization }} locCache Cache all'interno della quale inserire l'informazione della frase con le localizzazioni
      * @param {string} direction Direzione della traduzione, rappresenta la lingua base in cui aspettarsi il testo e le varie lingue in cui viene tradotta.
      * Ad esempio, "en->it" indica che il parametro **left** è valido per le localizzazioni in inglese, mentre nell'elemento 0 del parametro **right**
      * è presente l'unica traduzione in italiano, per definire più traduzioni sul lato destro della freccia bisogna concatenarle con la virgola, ad esempio "en->it,jp,ecc"
      * @param {string} left Valore della frase per la lingua specificata nel lato immediatamente sinistro alla freccia del parametro **direction**
      * @param {string} right Array con i valori facenti riferimento all'N-esima lingua del lato destro del parametro **direction**
      */
-    static set(locCache, direction, left, right) {
+    set(direction, left, right) {
         let parsingRegex = /([a-zA-Z]+)[\s]*->[\s]*([a-zA-Z,\s]+)+/g;
         var parsingRes = parsingRegex.exec(direction);
         let from = parsingRes[1];
         let to = parsingRes[2].replace(/\s/g, '').split(',');
         let localeFrom = LocaleDefinitions.getByAlias(from);
-        BaseLocalization._set(locCache, left, localeFrom.id, left);
+        this._set(left, localeFrom.id, left);
         to.forEach((t, index) => {
             let localeTo = LocaleDefinitions.getByAlias(t);
-            BaseLocalization._set(locCache, left, localeTo.id, right[index]);
+            this._set(left, localeTo.id, right[index]);
         });
     }
     /**
      * Imposta all'interno della cache specificata un'unica traduzione partendo da un testo di base
      *
-     * @param {{ [id: string]: ItemLocalization }} locCache Cache all'interno della quale inserire l'informazione del testo con le localizzazioni
      * @param {string} text Testo da tradurre
      * @param {string} culture Lingua per cui inserire la traduzione
      * @param {string} translation Traduzione del **text** nella lingua specificata da **culture**
      * @param {boolean} token Indica se il **text** è un token o è una frase normale
      */
-    static _set(locCache, text, culture, translation, token) {
-        let item = BaseLocalization.findByText(locCache, text, token);
+    _set(text, culture, translation, token) {
+        let item = this.get(text, token);
         if (!item) {
-            locCache[text] = new ItemLocalization(token, text, [new SpecializedLocalization(culture, translation)]);
+            this.LocCache[text] = new ItemLocalization(token, text, [new SpecializedLocalization(culture, translation)]);
             return;
         }
-        var trs = BaseLocalization.translationByCulture(item, culture);
+        var trs = this.translationByCulture(item, culture);
         if (trs) {
             console.warn("Localization already loaded for sentence '" + text + "' and culture " + culture);
             return;
@@ -232,18 +159,15 @@ class BaseLocalization {
     /**
      * Partendo da una cache di localizzazione, dato un testo che può essere o meno un token, cerca quell'elemento all'interno della cache
      *
-     * @param {{ [id: string]: ItemLocalization }} locCache Cache all'interno del quale cercare il **text**
-     * @param {string} text Testo da cercare nella **locCache**
+     * @param {string} text Testo da cercare nella **LocCache**
      * @param {boolean} allowtokens Indica se l'elemento cercato può essere un token o se dev'essere per forza una frase (per evitare rari
      * casi di collisione in cui magari un token è uguale a una frase tradotta)
      *
      * @returns {ItemLocalization} Informazioni di localizzazione per il **text** cercato
      */
-    static findByText(locCache, text, allowtokens) {
-        let possibleItem = locCache[text];
-        if (!possibleItem)
-            return null;
-        var item = allowtokens || !possibleItem.token ? possibleItem : null;
+    get(text, allowtokens) {
+        let possibleItem = this.LocCache[text];
+        var item = possibleItem && (allowtokens || !possibleItem.token) ? possibleItem : null;
         return item;
     }
     /**
@@ -254,7 +178,7 @@ class BaseLocalization {
      *
      * @returns {SpecializedLocalization} Informazioni di localizzazione specifiche della lingua richiesta
      */
-    static translationByCulture(item, culture) {
+    translationByCulture(item, culture) {
         for (let i = 0; i < item.translations.length; i++) {
             let trl = item.translations[i];
             if (trl.culture == culture)
@@ -262,11 +186,171 @@ class BaseLocalization {
         }
         return null;
     }
+}
+
+var BaseLocalizationTokens;
+(function (BaseLocalizationTokens) {
+    BaseLocalizationTokens["getDateMonthPosition"] = "getDateMonthPosition";
+    BaseLocalizationTokens["getDisplayDateMonthPosition"] = "getDisplayDateMonthPosition";
+    BaseLocalizationTokens["getLocale"] = "getLocale";
+    BaseLocalizationTokens["getSmallDateFormat"] = "getSmallDateFormat";
+    BaseLocalizationTokens["getDefaultDateFormat"] = "getDefaultDateFormat";
+    BaseLocalizationTokens["getSmallDateDisplayFormat"] = "getSmallDateDisplayFormat";
+    BaseLocalizationTokens["getFullDateFormat"] = "getFullDateFormat";
+    BaseLocalizationTokens["getFullDateDisplayFormat"] = "getFullDateDisplayFormat";
+    BaseLocalizationTokens["getFullDateFormatNoSeconds"] = "getFullDateFormatNoSeconds";
+    BaseLocalizationTokens["getFullDateDisplayFormatNoSeconds"] = "getFullDateDisplayFormatNoSeconds";
+})(BaseLocalizationTokens || (BaseLocalizationTokens = {}));
+
+/** Classe astratta che rappresenta lo stato di persistenza fra la libreria e uno storage */
+class LocalePersistor {
+    constructor() {
+        /** Chiave su cui salvare il locale */
+        this.LOCALE = "LOCALE";
+    }
+}
+
+/** Locale da utilizzare per le traduzioni */
+const LOC_LOCALE = new InjectionToken('LOC_LOCALE');
+/** Policy da utilizzare per traduzioni mancanti */
+const LOC_MISSING_POLICY = new InjectionToken('LOC_MISSING_POLICY');
+
+/**
+ * Classe singleton che contiene le traduzioni di base (per evitare di ripeterle in oggi classe di traduzione) e le funzioni base per
+ * inserire e leggere traduzioni in/da una cache
+ */
+class BaseLocalization {
+    /**
+     * Costruttore. Da qui utilizzando il metodo statico **BaseLocalization.set** si va a popolare la cache delle traduzioni **BaseTranslations**
+     */
+    constructor(LocalePersistor, defaultLocale) {
+        this.LocalePersistor = LocalePersistor;
+        /**
+         * Cache di tutte le localizzazioni di base
+         */
+        this.LocCache = {};
+        /**
+         * Locale di riferimento per tutte le traduzioni
+         */
+        this.Locale = new ReplaySubject(1);
+        // Recupero il locale alla partenza del BaseLocalization in modo, spero di dare tempo all'applicazione di tirarlo su
+        this.LocalePersistor.recover().pipe(take(1)).subscribe((l) => __awaiter(this, void 0, void 0, function* () {
+            if (!l) {
+                l = defaultLocale;
+                this.LocalePersistor.persist(defaultLocale);
+            }
+            this.Locale.next(l);
+        }));
+        this.Persistor = new LocalizationPersistor(this.LocCache);
+        this.Persistor.set("en->it", "Remove", ["Elimina"]);
+        this.Persistor.set("en->it", "Paging", ["Paginazione"]);
+        this.Persistor.set("en->it", "Yes", ["Si"]);
+        this.Persistor.set("en->it", "No", ["No"]);
+        this.Persistor.set("en->it", "YES", ["SI'"]);
+        this.Persistor.set("en->it", "NO", ["NO"]);
+        this.Persistor.set("en->it", "Found objects", ["Risultati trovati"]);
+        this.Persistor.set("en->it", "Loading data...", ["Carico i dati..."]);
+        this.Persistor.set("en->it", "Error during save operations", ["Errori durante il salvataggio"]);
+        this.Persistor.set("en->it", "Error", ["Errore"]);
+        this.Persistor.set("en->it", "Warning", ["Avviso"]);
+        this.Persistor.set("en->it", "Information", ["Informazione"]);
+        this.Persistor.set("en->it", "Save", ["Salva"]);
+        this.Persistor.set("en->it", "Back", ["Indietro"]);
+        this.Persistor.set("en->it", "From", ["Da"]);
+        this.Persistor.set("en->it", "To", ["A"]);
+        this.Persistor.set("en->it", "View Chart", ["Vedi Grafico"]);
+        this.Persistor.set("en->it", "View Table", ["Vedi Tabella"]);
+        this.Persistor.set("en->it", "Notes", ["Note"]);
+        this.Persistor.set("en->it", "Edit Notes", ["Modifica Note"]);
+        this.Persistor.set("en->it", "Cancel", ["Annulla"]);
+        this.Persistor.set("en->it", "Confirm", ["Conferma"]);
+        this.Persistor.set("en->it", "View", ["Visualizza"]);
+        this.Persistor.set("en->it", "Close", ["Chiudi"]);
+        this.Persistor.set("en->it", "Select", ["Seleziona"]);
+        this.Persistor.set("en->it", "Meter Reading registered successfully", ["Lettura registrata correttamente"]);
+        this.Persistor.set("en->it", "Validation errors during save operations", ["Errori di validazione durante il salvataggio"]);
+        this.Persistor.set("en->it", "Can't register reading", ["Impossibile registrare la lettura"]);
+        this.Persistor.set("en->it", "Electricity", ["Elettricita"]);
+        this.Persistor.set("en->it", "Gas", ["Gas"]);
+        this.Persistor.set("en->it", "Water", ["Acqua"]);
+        this.Persistor.set("en->it", "Delete", ["Elimina"]);
+        this.Persistor.set("en->it", "This operation cannot be reverted", ["Questa operazione non puo' essere annullata"]);
+        this.Persistor.set("en->it", "Hide", ["Nascondi"]);
+        // Helper validazione
+        this.Persistor.set("en->it", "Required field", ["Campo richiesto"]);
+        this.Persistor.set("en->it", "Wrong field format", ["Formato campo errato"]);
+        this.Persistor.set("en->it", "Wrong field format or field missing", ["Formato campo errato o campo mancante"]);
+        this.Persistor.set("en->it", "You don't have the required permissions to view this page. The navigation has been blocked", ["Non si hanno privilegi a sufficienza per accedere a questa pagina. La navigazione e' stata bloccata"]);
+        // Informazioni sulle date
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getDateMonthPosition, "0", ["1"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getDisplayDateMonthPosition, "1", ["1"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getLocale, "en-US", ["it-IT"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getSmallDateFormat, "MM/DD/YYYY", ["DD/MM/YYYY"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getDefaultDateFormat, "MM/DD/YYYY", ["MM/DD/YYYY"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getSmallDateDisplayFormat, "DD/MM/YYYY", ["DD/MM/YYYY"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getFullDateFormat, "MM/DD/YYYY HH:mm:ss", ["DD/MM/YYYY HH:mm:ss"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getFullDateDisplayFormat, "DD/MM/YYYY HH:mm:ss", ["DD/MM/YYYY HH:mm:ss"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getFullDateFormatNoSeconds, "MM/DD/YYYY HH:mm", ["DD/MM/YYYY HH:mm"]);
+        this.Persistor.setToken("en->it", BaseLocalizationTokens.getFullDateDisplayFormatNoSeconds, "DD/MM/YYYY HH:mm", ["DD/MM/YYYY HH:mm"]);
+    }
 }
+BaseLocalization.ɵprov = i0.ɵɵdefineInjectable({ factory: function BaseLocalization_Factory() { return new BaseLocalization(i0.ɵɵinject(LocalePersistor), i0.ɵɵinject(LOC_LOCALE)); }, token: BaseLocalization, providedIn: "root" });
 BaseLocalization.decorators = [
-    { type: Injectable }
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+BaseLocalization.ctorParameters = () => [
+    { type: LocalePersistor },
+    { type: String, decorators: [{ type: Inject, args: [LOC_LOCALE,] }] }
+];
+
+// Angular
+/**
+ * Pipe che permette di formattare una data in base al formato specificato. Utilizza il **DateService** di **@esfaenza/extensions** per ricondurre l'input a una data valida
+ */
+class LocDatePipe {
+    /**
+     * @ignore
+     */
+    constructor(dts) {
+        this.dts = dts;
+    }
+    /**
+     * Trasformazione della data in input in base al formato richiesto
+     *
+     * @param {any} value Valore da ricondurre ad una data e formattare
+     * @param {string} format Formato in output della data da visualizzare
+     *
+     * @returns {string} Data formattata in base al formato
+     */
+    transform(value, format = "DD/MM/YYYY") {
+        if (value == null || value === "")
+            return null;
+        if (!this.dts) {
+            console.error("Tentativo di usare loc_date senza DateService. È possibile importare DateService installando e configurando il pacchetto @esfaenza/extensions");
+            return null;
+        }
+        var detatchedValue = JSON.parse(JSON.stringify(value));
+        var dt = this.dts.getDateConvertion(detatchedValue);
+        return dt.format(format);
+    }
+}
+LocDatePipe.decorators = [
+    { type: Pipe, args: [{ name: "loc_date", pure: true },] }
 ];
-BaseLocalization.ctorParameters = () => [];
+LocDatePipe.ctorParameters = () => [
+    { type: DateService, decorators: [{ type: Optional }] }
+];
+
+/**
+ * Enum che rappresenta le policy di comportamento qualore il sistema di localizzazione non trovi la localizzazione cercata,
+ * usare **ThrowException** solo se ci si sente infallibili o si vuole debuggare in maniera approfondita l'applicazione
+ */
+var LocalizationMissingPolicy;
+(function (LocalizationMissingPolicy) {
+    LocalizationMissingPolicy[LocalizationMissingPolicy["PrintEmpty"] = 0] = "PrintEmpty";
+    LocalizationMissingPolicy[LocalizationMissingPolicy["PrintSource"] = 1] = "PrintSource";
+    LocalizationMissingPolicy[LocalizationMissingPolicy["ThrowException"] = 2] = "ThrowException";
+})(LocalizationMissingPolicy || (LocalizationMissingPolicy = {}));
 
 /**
  * Classe di localizzazione estendibile che permette di specificare le proprie localizzazioni e comunque rendere disponibili le localizzazioni globali
@@ -275,17 +359,23 @@ class LocalizationService {
     /**
      * Costruttore
      *
-     * @param {string} baseLoc Locale da utilizzare nel momento che questo servizio richiede le traduzioni
+     * @param {string} Locale Locale da utilizzare nel momento che questo servizio richiede le traduzioni
      * @param {baseLocalization} baseLocalization Classe base di localizzazione già fornita a livello di root dalla libreria stessa.
      * È sufficiente iniettarla nell'eventuale costruttore che estende questa classe e passarla as-is
      */
-    constructor(baseLoc, baseLocalization) {
-        this.baseLoc = baseLoc;
-        this.baseLocalization = baseLocalization;
+    constructor(injector) {
+        this.injector = injector;
         /**
          * Cache di tutte le localizzazioni disonibili all'interno di questa classe
          */
         this.TranslationCache = {};
+        this.LocalePersistor = this.injector.get(LocalePersistor);
+        this.baseLocalization = this.injector.get(BaseLocalization);
+        this.onMissing = this.injector.get(LOC_MISSING_POLICY);
+        this.Persistor = new LocalizationPersistor(this.TranslationCache);
+        this.baseLocalization.Locale.subscribe(lr => {
+            this.Locale = lr;
+        });
     }
     /**
      * Imposta la localizzazione di un token all'interno della **TranslationCache**
@@ -298,7 +388,7 @@ class LocalizationService {
      * @param {string} right Array con i valori facenti riferimento all'N-esima lingua del lato destro del parametro **direction**
      */
     setToken(direction, token, left, right) {
-        BaseLocalization.setToken(this.TranslationCache, direction, token, left, right);
+        this.Persistor.setToken(direction, token, left, right);
     }
     /**
      * Imposta la localizzazione di una frase all'interno della **TranslationCache**
@@ -310,7 +400,13 @@ class LocalizationService {
      * @param {string} right Array con i valori facenti riferimento all'N-esima lingua del lato destro del parametro **direction**
      */
     set(direction, left, right) {
-        BaseLocalization.set(this.TranslationCache, direction, left, right);
+        // Controlla di non reinserire la stessa localizzazione presente nel BaseLocalization
+        // i controlli per il non reinserimento della stessa localizzazione all'interno della stessa istanza è fatto lato Persistor
+        if (this.baseLocalization.Persistor.get(left, false)) {
+            console.warn(`La localizzazione per ${left} è già presente fra le localizzazioni base, ignoro l'operazione`);
+            return;
+        }
+        this.Persistor.set(direction, left, right);
     }
     /**
      * Localizza un token
@@ -331,85 +427,51 @@ class LocalizationService {
      * @returns {string} Frase localizzata
      */
     loc(text, allowtokens) {
+        if (!this.Locale)
+            throw "Il sistema di localizzazione non ha ancora caricato il Locale, assicurarsi di caricare l'APP solo al retrieve del locale'";
         if (!text || text == "undefined")
             return "";
-        // Questo può succedere solo se qualcuno crea questa service a manazza. In quel caso prendo la classe di default e basta
-        if (this.baseLocalization == null)
-            this.baseLocalization = new BaseLocalization();
         // Prendo la localizzazione o dalla cache attuale o dalla cache del servizio base
-        var item = BaseLocalization.findByText(this.TranslationCache, text, allowtokens) || BaseLocalization.findByText(this.baseLocalization.BaseTranslations, text, allowtokens);
+        var item = this.Persistor.get(text, allowtokens) || this.baseLocalization.Persistor.get(text, allowtokens);
         if (!item) {
-            console.error("Couldn't find localization for '" + text + "'");
-            return "";
+            let message = `Impossibile trovare la localizzazione per '${text}'`;
+            switch (this.onMissing) {
+                case LocalizationMissingPolicy.PrintEmpty:
+                    console.error(message);
+                    return "";
+                case LocalizationMissingPolicy.PrintSource:
+                    console.warn(message);
+                    return text;
+                case LocalizationMissingPolicy.ThrowException:
+                    throw message;
+            }
         }
-        var loc = BaseLocalization.translationByCulture(item, this.baseLoc);
+        var loc = this.Persistor.translationByCulture(item, this.Locale);
         if (!loc) {
-            console.error("Couldn't find localization for '" + text + "', culture " + this.baseLoc);
+            console.error("Impossibile trovare la localizzazione per '" + text + "', culture " + this.Locale);
             return "";
         }
         return loc.translation;
     }
-    /**
-     * Localizzazione per Severity classiche (E per errore, W per warning e I per info)
-     *
-     * @param {string} text Severity da tradurre
-     *
-     * @returns {string} Severity tradotta
-     */
-    locSeverity(text) {
-        if (text == "E")
-            return this.loc("Error");
-        if (text == "W")
-            return this.loc("Warning");
-        if (text == "I")
-            return this.loc("Information");
-        return "";
+    changeLocale(newLocale) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let locale = yield this.LocalePersistor.recover().toPromise();
+            if (newLocale == locale) {
+                console.info("Il locale richiesto è lo stesso del locale attuale. Ignoro l'operazione");
+                return;
+            }
+            else {
+                yield this.LocalePersistor.persist(newLocale).toPromise();
+                location.reload();
+            }
+        });
     }
 }
 LocalizationService.decorators = [
     { type: Injectable }
 ];
 LocalizationService.ctorParameters = () => [
-    { type: String, decorators: [{ type: Inject, args: [LOC_LOCALE,] }] },
-    { type: BaseLocalization }
-];
-
-// Angular
-/**
- * Pipe che permette di formattare una data in base al formato specificato. Utilizza il **DateService** di **@esfaenza/extensions** per ricondurre l'input a una data valida
- */
-class LocDatePipe {
-    /**
-     * @ignore
-     */
-    constructor(dts) {
-        this.dts = dts;
-    }
-    /**
-     * Trasformazione della data in input in base al formato richiesto
-     *
-     * @param {any} value Valore da ricondurre ad una data e formattare
-     * @param {string} format Formato in output della data da visualizzare
-     *
-     * @returns {string} Data formattata in base al formato
-     */
-    transform(value, format = "DD/MM/YYYY") {
-        if (value == null || value === "")
-            return null;
-        if (!this.dts) {
-            console.error("Tentativo di usare loc_date senza DateService. È possibile importare DateService installando e configurando il pacchetto @esfaenza/extensions");
-            return null;
-        }
-        var detatchedValue = JSON.parse(JSON.stringify(value));
-        var dt = this.dts.getDateConvertion(detatchedValue);
-        return dt.format(format);
-    }
-}
-LocDatePipe.decorators = [
-    { type: Pipe, args: [{ name: "loc_date", pure: true },] }
-];
-LocDatePipe.ctorParameters = () => [
-    { type: DateService, decorators: [{ type: Optional }] }
+    { type: Injector }
 ];
 
 // Angular
@@ -448,6 +510,24 @@ LocalizePipe.ctorParameters = () => [
     { type: LocalizationService }
 ];
 
+// Angular
+class LocalStorageLocalePersistor extends LocalePersistor {
+    /** @ignore Vedi classe base */
+    persist(locale) {
+        localStorage.setItem(this.LOCALE, locale);
+        return of(true).pipe(first());
+    }
+    /** @ignore Vedi classe base */
+    recover() {
+        var ret = localStorage.getItem(this.LOCALE);
+        return of(ret).pipe(first());
+    }
+}
+LocalStorageLocalePersistor.decorators = [
+    { type: Injectable }
+];
+
+// Angular
 class LocalizationModule {
     static forRoot(config) {
         return {
@@ -455,7 +535,9 @@ class LocalizationModule {
             providers: [
                 LocalizationService,
                 BaseLocalization,
-                { provide: LOC_LOCALE, useValue: (config === null || config === void 0 ? void 0 : config.locale) || 'it-IT' }
+                { provide: LOC_LOCALE, useValue: (config === null || config === void 0 ? void 0 : config.defaultLocale) || 'it-IT' },
+                { provide: LOC_MISSING_POLICY, useValue: (config === null || config === void 0 ? void 0 : config.localizationMissingPolicy) || LocalizationMissingPolicy.PrintEmpty },
+                { provide: LocalePersistor, useClass: (config === null || config === void 0 ? void 0 : config.localePersistor) || LocalStorageLocalePersistor },
             ]
         };
     }
@@ -467,6 +549,12 @@ LocalizationModule.decorators = [
             },] }
 ];
 
+/**
+ * Classe di configurazione per il modulo di localizzazione
+ */
+class LocalizationModuleConfig {
+}
+
 /*
  * Public API Surface of localizations
  */
@@ -475,5 +563,5 @@ LocalizationModule.decorators = [
  * Generated bundle index. Do not edit.
  */
 
-export { LOC_LOCALE, LocDatePipe, LocalizationModule, LocalizationModuleConfig, LocalizationService, LocalizePipe, BaseLocalization as ɵa };
+export { BaseLocalization, BaseLocalizationTokens, LOC_LOCALE, LOC_MISSING_POLICY, LocDatePipe, LocalizationMissingPolicy, LocalizationModule, LocalizationModuleConfig, LocalizationService, LocalizePipe, LocalePersistor as ɵa, LocalStorageLocalePersistor as ɵb };
 //# sourceMappingURL=esfaenza-localizations.js.map