@esfaenza/localizations 19.2.11 → 19.2.13

package/esm2020/esfaenza-localizations.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNmYWVuemEtbG9jYWxpemF0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2xvY2FsaXphdGlvbnMvc3JjL2VzZmFlbnphLWxvY2FsaXphdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/lib/core/localization.base.mjs

@@ -0,0 +1,80 @@
+import { Inject, Injectable } from "@angular/core";
+import { LocalizationPersistor } from "./localization.persistor";
+import { BaseLocalizationTokens } from "../models/BaseLocalizationTokens";
+import { take } from "rxjs/operators";
+import { ReplaySubject } from "rxjs";
+import { LOC_LOCALE } from "../tokens";
+import * as i0 from "@angular/core";
+import * as i1 from "../locale-persistor/LocalePersistor";
+/**
+ * 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
+ */
+export 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(async (l) => {
+            if (!l) {
+                l = defaultLocale;
+                this.LocalePersistor.persist(defaultLocale);
+            }
+            this.Locale.next(l);
+        });
+        this.Persistor = new LocalizationPersistor(this.LocCache);
+        this.Persistor.set("it->en", "Sì", ["Yes"]);
+        this.Persistor.set("it->en", "No", ["No"]);
+        this.Persistor.set("it->en", "Errore", ["Error"]);
+        this.Persistor.set("it->en", "Avviso", ["Warning"]);
+        this.Persistor.set("it->en", "Informazione", ["Information"]);
+        this.Persistor.set("it->en", "Salva", ["Save"]);
+        this.Persistor.set("it->en", "Indietro", ["Back"]);
+        this.Persistor.set("it->en", "Da", ["From"]);
+        this.Persistor.set("it->en", "A", ["To"]);
+        this.Persistor.set("it->en", "Note", ["Notes"]);
+        this.Persistor.set("it->en", "Modifica Note", ["Edit Notes"]);
+        this.Persistor.set("it->en", "Annulla", ["Cancel"]);
+        this.Persistor.set("it->en", "Conferma", ["Confirm"]);
+        this.Persistor.set("it->en", "Visualizza", ["View"]);
+        this.Persistor.set("it->en", "Elimina", ["Delete"]);
+        this.Persistor.set("it->en", "Chiudi", ["Close"]);
+        this.Persistor.set("it->en", "Seleziona", ["Select"]);
+        this.Persistor.set("it->en", "Elettricità", ["Electricity"]);
+        this.Persistor.set("it->en", "Gas", ["Gas"]);
+        this.Persistor.set("it->en", "Acqua", ["Water"]);
+        this.Persistor.set("it->en", "Questa operazione non può essere annullata", ["This operation cannot be reverted"]);
+        this.Persistor.set("it->en", "Nascondi", ["Hide"]);
+        // 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.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BaseLocalization, deps: [{ token: i1.LocalePersistor }, { token: LOC_LOCALE }], target: i0.ɵɵFactoryTarget.Injectable });
+BaseLocalization.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BaseLocalization, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: BaseLocalization, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.LocalePersistor }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOC_LOCALE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"localization.base.js","sourceRoot":"","sources":["../../../../../projects/localizations/src/lib/core/localization.base.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from \"@angular/core\";\r\nimport { ItemLocalization } from \"../models/ItemLocalization\";\r\nimport { LocalizationPersistor } from \"./localization.persistor\";\r\nimport { BaseLocalizationTokens } from \"../models/BaseLocalizationTokens\";\r\nimport { LocalePersistor } from \"../locale-persistor/LocalePersistor\";\r\nimport { take } from \"rxjs/operators\";\r\nimport { ReplaySubject } from \"rxjs\";\r\nimport { LOC_LOCALE } from \"../tokens\";\r\n\r\n/**\r\n * Classe singleton che contiene le traduzioni di base (per evitare di ripeterle in oggi classe di traduzione) e le funzioni base per \r\n * inserire e leggere traduzioni in/da una cache\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class BaseLocalization {\r\n\r\n    /**\r\n     * Cache di tutte le localizzazioni di base\r\n     */\r\n    public LocCache: { [id: string]: ItemLocalization } = {};\r\n\r\n    /**\r\n     * Persistor delle localizzazioni relativo a questa classe\r\n     */\r\n    public Persistor: LocalizationPersistor;\r\n\r\n    /**\r\n     * Locale di riferimento per tutte le traduzioni\r\n     */\r\n    public Locale: ReplaySubject<string> = new ReplaySubject<string>(1);\r\n\r\n    /**\r\n     * Costruttore. Da qui utilizzando il metodo statico **BaseLocalization.set** si va a popolare la cache delle traduzioni **BaseTranslations**\r\n     */\r\n    constructor(public LocalePersistor: LocalePersistor, @Inject(LOC_LOCALE) defaultLocale: string) {\r\n\r\n        // Recupero il locale alla partenza del BaseLocalization in modo, spero di dare tempo all'applicazione di tirarlo su\r\n        this.LocalePersistor.recover().pipe(take(1)).subscribe(async l => {\r\n            if (!l) {\r\n                l = defaultLocale;\r\n                this.LocalePersistor.persist(defaultLocale);\r\n            }\r\n            this.Locale.next(l)\r\n        });\r\n\r\n        this.Persistor = new LocalizationPersistor(this.LocCache); \r\n\r\n        this.Persistor.set(\"it->en\", \"Sì\", [\"Yes\"]);\r\n        this.Persistor.set(\"it->en\", \"No\", [\"No\"]);\r\n        this.Persistor.set(\"it->en\", \"Errore\", [\"Error\"]);\r\n        this.Persistor.set(\"it->en\", \"Avviso\", [\"Warning\"]);\r\n        this.Persistor.set(\"it->en\", \"Informazione\", [\"Information\"]);\r\n        this.Persistor.set(\"it->en\", \"Salva\", [\"Save\"]);\r\n        this.Persistor.set(\"it->en\", \"Indietro\", [\"Back\"]);\r\n        this.Persistor.set(\"it->en\", \"Da\", [\"From\"]);\r\n        this.Persistor.set(\"it->en\", \"A\", [\"To\"]);\r\n        this.Persistor.set(\"it->en\", \"Note\", [\"Notes\"]);\r\n        this.Persistor.set(\"it->en\", \"Modifica Note\", [\"Edit Notes\"]);\r\n        this.Persistor.set(\"it->en\", \"Annulla\", [\"Cancel\"]);\r\n        this.Persistor.set(\"it->en\", \"Conferma\", [\"Confirm\"]);\r\n        this.Persistor.set(\"it->en\", \"Visualizza\", [\"View\"]);\r\n        this.Persistor.set(\"it->en\", \"Elimina\", [\"Delete\"]);\r\n        this.Persistor.set(\"it->en\", \"Chiudi\", [\"Close\"]);\r\n        this.Persistor.set(\"it->en\", \"Seleziona\", [\"Select\"]);\r\n        this.Persistor.set(\"it->en\", \"Elettricità\", [\"Electricity\"]);\r\n        this.Persistor.set(\"it->en\", \"Gas\", [\"Gas\"]);\r\n        this.Persistor.set(\"it->en\", \"Acqua\", [\"Water\"]);\r\n        this.Persistor.set(\"it->en\", \"Questa operazione non può essere annullata\", [\"This operation cannot be reverted\"]);\r\n        this.Persistor.set(\"it->en\", \"Nascondi\", [\"Hide\"]);\r\n\r\n        // Informazioni sulle date\r\n        this.Persistor.setToken(\"en->it\", BaseLocalizationTokens.getDateMonthPosition, \"0\", [\"1\"]);\r\n        this.Persistor.setToken(\"en->it\", BaseLocalizationTokens.getDisplayDateMonthPosition, \"1\", [\"1\"]);\r\n        this.Persistor.setToken(\"en->it\", BaseLocalizationTokens.getLocale, \"en-US\", [\"it-IT\"]);\r\n        this.Persistor.setToken(\"en->it\", BaseLocalizationTokens.getSmallDateFormat, \"MM/DD/YYYY\", [\"DD/MM/YYYY\"]);\r\n        this.Persistor.setToken(\"en->it\", BaseLocalizationTokens.getDefaultDateFormat, \"MM/DD/YYYY\", [\"MM/DD/YYYY\"]);\r\n        this.Persistor.setToken(\"en->it\", BaseLocalizationTokens.getSmallDateDisplayFormat, \"DD/MM/YYYY\", [\"DD/MM/YYYY\"]);\r\n        this.Persistor.setToken(\"en->it\", BaseLocalizationTokens.getFullDateFormat, \"MM/DD/YYYY HH:mm:ss\", [\"DD/MM/YYYY HH:mm:ss\"]);\r\n        this.Persistor.setToken(\"en->it\", BaseLocalizationTokens.getFullDateDisplayFormat, \"DD/MM/YYYY HH:mm:ss\", [\"DD/MM/YYYY HH:mm:ss\"]);\r\n        this.Persistor.setToken(\"en->it\", BaseLocalizationTokens.getFullDateFormatNoSeconds, \"MM/DD/YYYY HH:mm\", [\"DD/MM/YYYY HH:mm\"]);\r\n        this.Persistor.setToken(\"en->it\", BaseLocalizationTokens.getFullDateDisplayFormatNoSeconds, \"DD/MM/YYYY HH:mm\", [\"DD/MM/YYYY HH:mm\"]);\r\n    }\r\n}"]}

package/esm2020/lib/core/localization.persistor.mjs

@@ -0,0 +1,103 @@
+import { ItemLocalization } from "../models/ItemLocalization";
+import { LocaleDefinitions } from "../models/LocaleDefinitions";
+import { SpecializedLocalization } from "../models/SpecializedLocalization";
+export class LocalizationPersistor {
+    constructor(LocCache = null) {
+        this.LocCache = LocCache;
+    }
+    /**
+     * Imposta la localizzazione di un token all'interno della cache scelta
+     *
+     * @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} token Nome del token
+     * @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**
+     */
+    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);
+        this._set(token, localeFrom.id, left, true);
+        to.forEach((t, index) => {
+            let localeTo = LocaleDefinitions.getByAlias(t);
+            this._set(token, localeTo.id, right[index], true);
+        });
+    }
+    /**
+     * Imposta la localizzazione di una frase all'interno della cache scelta
+     *
+     * @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**
+     */
+    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);
+        this._set(left, localeFrom.id, left);
+        to.forEach((t, index) => {
+            let localeTo = LocaleDefinitions.getByAlias(t);
+            this._set(left, localeTo.id, right[index]);
+        });
+    }
+    /**
+     * Imposta all'interno della cache specificata un'unica traduzione partendo da un testo di base
+     *
+     * @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
+     */
+    _set(text, culture, translation, token) {
+        let item = this.get(text, token);
+        if (!item) {
+            this.LocCache[text] = new ItemLocalization(token, text, [new SpecializedLocalization(culture, translation)]);
+            return;
+        }
+        var trs = this.translationByCulture(item, culture);
+        if (trs) {
+            //console.warn("Localization already loaded for sentence '" + text + "' and culture " + culture);
+            return;
+        }
+        item.translations.push(new SpecializedLocalization(culture, translation));
+    }
+    /**
+     * Partendo da una cache di localizzazione, dato un testo che può essere o meno un token, cerca quell'elemento all'interno della cache
+     *
+     * @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
+     */
+    get(text, allowtokens) {
+        let possibleItem = this.LocCache[text];
+        var item = possibleItem && (allowtokens || !possibleItem.token) ? possibleItem : null;
+        return item;
+    }
+    /**
+     * Date le informazioni di localizzazione per un testo cerca e restituisce la traduzione per una lingua specifica
+     *
+     * @param {ItemLocalization} Informazioni di localizzazione
+     * @param {string} culture Lingua della traduzione richiesta
+     *
+     * @returns {SpecializedLocalization} Informazioni di localizzazione specifiche della lingua richiesta
+     */
+    translationByCulture(item, culture) {
+        for (let i = 0; i < item.translations.length; i++) {
+            let trl = item.translations[i];
+            if (trl.culture == culture)
+                return trl;
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"localization.persistor.js","sourceRoot":"","sources":["../../../../../projects/localizations/src/lib/core/localization.persistor.ts"],"names":[],"mappings":"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","sourcesContent":["import { ItemLocalization } from \"../models/ItemLocalization\";\r\nimport { LocaleDefinitions } from \"../models/LocaleDefinitions\";\r\nimport { SpecializedLocalization } from \"../models/SpecializedLocalization\";\r\n\r\nexport class LocalizationPersistor {\r\n\r\n    constructor(private LocCache: { [id: string]: ItemLocalization } = null) { }\r\n\r\n    /**\r\n     * Imposta la localizzazione di un token all'interno della cache scelta\r\n     * \r\n     * @param {string} direction Direzione della traduzione, rappresenta la lingua base in cui aspettarsi il testo e le varie lingue in cui viene tradotta.\r\n     * Ad esempio, \"en->it\" indica che il parametro **left** è valido per le localizzazioni in inglese, mentre nell'elemento 0 del parametro **right** \r\n     * è 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\"\r\n     * @param {string} token Nome del token\r\n     * @param {string} left Valore del token per la lingua specificata nel lato immediatamente sinistro alla freccia del parametro **direction**\r\n     * @param {string} right Array con i valori facenti riferimento all'N-esima lingua del lato destro del parametro **direction**\r\n     */\r\n    public setToken(direction: string, token: string, left: string, right: string[]) {\r\n        let parsingRegex = /([a-zA-Z]+)[\\s]*->[\\s]*([a-zA-Z,\\s]+)+/g;\r\n        var parsingRes = parsingRegex.exec(direction);\r\n\r\n        let from = parsingRes[1];\r\n        let to: string[] = parsingRes[2].replace(/\\s/g, '').split(',');\r\n        let localeFrom = LocaleDefinitions.getByAlias(from);\r\n        this._set(token, localeFrom.id, left, true);\r\n\r\n        to.forEach((t, index) => {\r\n            let localeTo = LocaleDefinitions.getByAlias(t);\r\n            this._set(token, localeTo.id, right[index], true);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Imposta la localizzazione di una frase all'interno della cache scelta\r\n     * \r\n     * @param {string} direction Direzione della traduzione, rappresenta la lingua base in cui aspettarsi il testo e le varie lingue in cui viene tradotta.\r\n     * Ad esempio, \"en->it\" indica che il parametro **left** è valido per le localizzazioni in inglese, mentre nell'elemento 0 del parametro **right** \r\n     * è 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\"\r\n     * @param {string} left Valore della frase per la lingua specificata nel lato immediatamente sinistro alla freccia del parametro **direction**\r\n     * @param {string} right Array con i valori facenti riferimento all'N-esima lingua del lato destro del parametro **direction**\r\n     */\r\n    public set(direction: string, left: string, right: string[]) {\r\n        let parsingRegex = /([a-zA-Z]+)[\\s]*->[\\s]*([a-zA-Z,\\s]+)+/g;\r\n        var parsingRes = parsingRegex.exec(direction);\r\n\r\n        let from = parsingRes[1];\r\n        let to: string[] = parsingRes[2].replace(/\\s/g, '').split(',');\r\n        let localeFrom = LocaleDefinitions.getByAlias(from);\r\n        this._set(left, localeFrom.id, left);\r\n\r\n        to.forEach((t, index) => {\r\n            let localeTo = LocaleDefinitions.getByAlias(t);\r\n            this._set(left, localeTo.id, right[index]);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Imposta all'interno della cache specificata un'unica traduzione partendo da un testo di base\r\n     * \r\n     * @param {string} text Testo da tradurre\r\n     * @param {string} culture Lingua per cui inserire la traduzione\r\n     * @param {string} translation Traduzione del **text** nella lingua specificata da **culture**\r\n     * @param {boolean} token Indica se il **text** è un token o è una frase normale\r\n     */\r\n    private _set(text: string, culture: string, translation: string, token?: boolean) {\r\n        let item = this.get(text, token);\r\n        if (!item) {\r\n            this.LocCache[text] = new ItemLocalization(token, text, [new SpecializedLocalization(culture, translation)]);\r\n            return;\r\n        }\r\n\r\n        var trs = this.translationByCulture(item, culture);\r\n        if (trs) {\r\n            //console.warn(\"Localization already loaded for sentence '\" + text + \"' and culture \" + culture);\r\n            return;\r\n        }\r\n\r\n        item.translations.push(new SpecializedLocalization(culture, translation));\r\n    }\r\n\r\n    /**\r\n     * Partendo da una cache di localizzazione, dato un testo che può essere o meno un token, cerca quell'elemento all'interno della cache\r\n     * \r\n     * @param {string} text Testo da cercare nella **LocCache**\r\n     * @param {boolean} allowtokens Indica se l'elemento cercato può essere un token o se dev'essere per forza una frase (per evitare rari \r\n     * casi di collisione in cui magari un token è uguale a una frase tradotta)\r\n     * \r\n     * @returns {ItemLocalization} Informazioni di localizzazione per il **text** cercato\r\n     */\r\n    public get(text: string, allowtokens: boolean): ItemLocalization {\r\n        let possibleItem: ItemLocalization = this.LocCache[text];\r\n        var item = possibleItem && (allowtokens || !possibleItem.token) ? possibleItem : null;\r\n        return item;\r\n    }\r\n\r\n    /**\r\n     * Date le informazioni di localizzazione per un testo cerca e restituisce la traduzione per una lingua specifica\r\n     * \r\n     * @param {ItemLocalization} Informazioni di localizzazione\r\n     * @param {string} culture Lingua della traduzione richiesta\r\n     * \r\n     * @returns {SpecializedLocalization} Informazioni di localizzazione specifiche della lingua richiesta\r\n     */\r\n    public translationByCulture(item: ItemLocalization, culture: string): SpecializedLocalization {\r\n        for (let i = 0; i < item.translations.length; i++) {\r\n            let trl = item.translations[i];\r\n            if (trl.culture == culture)\r\n                return trl;\r\n        }\r\n\r\n        return null;\r\n    }\r\n}"]}

package/esm2020/lib/locale-persistor/LocalStorageCachePersistor.mjs

@@ -0,0 +1,25 @@
+// Angular
+import { Injectable } from "@angular/core";
+// RXJS
+import { of } from "rxjs";
+import { first } from "rxjs/operators";
+import { LocalePersistor } from "./LocalePersistor";
+import * as i0 from "@angular/core";
+export 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.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LocalStorageLocalePersistor, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+LocalStorageLocalePersistor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LocalStorageLocalePersistor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LocalStorageLocalePersistor, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9jYWxTdG9yYWdlQ2FjaGVQZXJzaXN0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9sb2NhbGl6YXRpb25zL3NyYy9saWIvbG9jYWxlLXBlcnNpc3Rvci9Mb2NhbFN0b3JhZ2VDYWNoZVBlcnNpc3Rvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxVQUFVO0FBQ1YsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxPQUFPO0FBQ1AsT0FBTyxFQUFjLEVBQUUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUN0QyxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDdkMsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLG1CQUFtQixDQUFDOztBQUdwRCxNQUFNLE9BQU8sMkJBQTRCLFNBQVEsZUFBZTtJQUU1RCwrQkFBK0I7SUFDeEIsT0FBTyxDQUFDLE1BQWM7UUFDekIsWUFBWSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBQzFDLE9BQU8sRUFBRSxDQUFDLElBQUksQ0FBQyxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBQ2xDLENBQUM7SUFFRCwrQkFBK0I7SUFDeEIsT0FBTztRQUNWLElBQUksR0FBRyxHQUFHLFlBQVksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQzVDLE9BQU8sRUFBRSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBQ2pDLENBQUM7O3dIQVpRLDJCQUEyQjs0SEFBM0IsMkJBQTJCOzJGQUEzQiwyQkFBMkI7a0JBRHZDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBBbmd1bGFyXHJcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5cclxuLy8gUlhKU1xyXG5pbXBvcnQgeyBPYnNlcnZhYmxlLCBvZiB9IGZyb20gXCJyeGpzXCI7XHJcbmltcG9ydCB7IGZpcnN0IH0gZnJvbSBcInJ4anMvb3BlcmF0b3JzXCI7XHJcbmltcG9ydCB7IExvY2FsZVBlcnNpc3RvciB9IGZyb20gXCIuL0xvY2FsZVBlcnNpc3RvclwiO1xyXG5cclxuQEluamVjdGFibGUoKVxyXG5leHBvcnQgY2xhc3MgTG9jYWxTdG9yYWdlTG9jYWxlUGVyc2lzdG9yIGV4dGVuZHMgTG9jYWxlUGVyc2lzdG9yIHtcclxuXHJcbiAgICAvKiogQGlnbm9yZSBWZWRpIGNsYXNzZSBiYXNlICovXHJcbiAgICBwdWJsaWMgcGVyc2lzdChsb2NhbGU6IHN0cmluZyk6IE9ic2VydmFibGU8Ym9vbGVhbj4ge1xyXG4gICAgICAgIGxvY2FsU3RvcmFnZS5zZXRJdGVtKHRoaXMuTE9DQUxFLCBsb2NhbGUpO1xyXG4gICAgICAgIHJldHVybiBvZih0cnVlKS5waXBlKGZpcnN0KCkpO1xyXG4gICAgfVxyXG5cclxuICAgIC8qKiBAaWdub3JlIFZlZGkgY2xhc3NlIGJhc2UgKi9cclxuICAgIHB1YmxpYyByZWNvdmVyKCk6IE9ic2VydmFibGU8c3RyaW5nPiB7XHJcbiAgICAgICAgdmFyIHJldCA9IGxvY2FsU3RvcmFnZS5nZXRJdGVtKHRoaXMuTE9DQUxFKTtcclxuICAgICAgICByZXR1cm4gb2YocmV0KS5waXBlKGZpcnN0KCkpO1xyXG4gICAgfVxyXG59Il19

package/esm2020/lib/locale-persistor/LocalePersistor.mjs

@@ -0,0 +1,8 @@
+/** Classe astratta che rappresenta lo stato di persistenza fra la libreria e uno storage */
+export class LocalePersistor {
+    constructor() {
+        /** Chiave su cui salvare il locale */
+        this.LOCALE = "LOCALE";
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9jYWxlUGVyc2lzdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbG9jYWxpemF0aW9ucy9zcmMvbGliL2xvY2FsZS1wZXJzaXN0b3IvTG9jYWxlUGVyc2lzdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLDRGQUE0RjtBQUM1RixNQUFNLE9BQWdCLGVBQWU7SUFBckM7UUFFSSxzQ0FBc0M7UUFDNUIsV0FBTSxHQUFXLFFBQVEsQ0FBQztJQWV4QyxDQUFDO0NBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSBcInJ4anNcIjtcclxuXHJcbi8qKiBDbGFzc2UgYXN0cmF0dGEgY2hlIHJhcHByZXNlbnRhIGxvIHN0YXRvIGRpIHBlcnNpc3RlbnphIGZyYSBsYSBsaWJyZXJpYSBlIHVubyBzdG9yYWdlICovXHJcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBMb2NhbGVQZXJzaXN0b3Ige1xyXG5cclxuICAgIC8qKiBDaGlhdmUgc3UgY3VpIHNhbHZhcmUgaWwgbG9jYWxlICovXHJcbiAgICBwcm90ZWN0ZWQgTE9DQUxFOiBzdHJpbmcgPSBcIkxPQ0FMRVwiO1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogU2FsdmEgaWwgTG9jYWxlXHJcbiAgICAgKiBcclxuICAgICAqIEBwYXJhbSB7c3RyaW5nfSBsb2NhbGUgTG9jYWxlIGRhIHNhbHZhcmVcclxuICAgICAqL1xyXG4gICAgcHVibGljIGFic3RyYWN0IHBlcnNpc3QobG9jYWxlOiBzdHJpbmcpOiBPYnNlcnZhYmxlPGJvb2xlYW4+O1xyXG5cclxuICAgIC8qKlxyXG4gICAgICogUmVjdXBlcmEgaWwgTG9jYWxlXHJcbiAgICAgKiBcclxuICAgICAqIEByZXR1cm5zIHtPYnNlcnZhYmxlPHN0cmluZz59IFZhbG9yZSBzYWx2YXRvIHBlciBpbCBsb2NhbGVcclxuICAgICAqL1xyXG4gICAgcHVibGljIGFic3RyYWN0IHJlY292ZXIoKTogT2JzZXJ2YWJsZTxzdHJpbmc+O1xyXG59Il19

package/esm2020/lib/localizations.module.mjs

@@ -0,0 +1,38 @@
+// Angular
+import { NgModule } from '@angular/core';
+// Pipe
+import { LocalizePipe } from './pipes/localize.pipe';
+// Servizi
+import { LocalizationService } from './localizations.service';
+import { BaseLocalization } from './core/localization.base';
+import { LocalePersistor } from './locale-persistor/LocalePersistor';
+import { LocalStorageLocalePersistor } from './locale-persistor/LocalStorageCachePersistor';
+import { LocalizationMissingPolicy } from './models/LocalizationMissingPolicy';
+import { LOC_DEBUG_MODE, LOC_LOCALE, LOC_MISSING_POLICY } from './tokens';
+import * as i0 from "@angular/core";
+export class LocalizationModule {
+    static forRoot(config) {
+        return {
+            ngModule: LocalizationModule,
+            providers: [
+                LocalizationService,
+                BaseLocalization,
+                { provide: LOC_LOCALE, useValue: config?.defaultLocale || 'it-IT' },
+                { provide: LOC_MISSING_POLICY, useValue: config?.localizationMissingPolicy || LocalizationMissingPolicy.PrintEmpty },
+                { provide: LocalePersistor, useClass: config?.localePersistor || LocalStorageLocalePersistor },
+                { provide: LOC_DEBUG_MODE, useValue: config?.debugMode || false },
+            ]
+        };
+    }
+}
+LocalizationModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LocalizationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LocalizationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: LocalizationModule, declarations: [LocalizePipe], exports: [LocalizePipe] });
+LocalizationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LocalizationModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LocalizationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [LocalizePipe],
+                    exports: [LocalizePipe]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/localizations.service.mjs

@@ -0,0 +1,148 @@
+import { Injectable, Injector } from '@angular/core';
+import { BaseLocalization } from './core/localization.base';
+import { LocalizationPersistor } from './core/localization.persistor';
+import { LocalePersistor } from './locale-persistor/LocalePersistor';
+import { LOC_MISSING_POLICY } from './tokens';
+import { LocalizationMissingPolicy } from './models/LocalizationMissingPolicy';
+import { LocaleDefinitions } from './models/LocaleDefinitions';
+import * as i0 from "@angular/core";
+/**
+ * Classe di localizzazione estendibile che permette di specificare le proprie localizzazioni e comunque rendere disponibili le localizzazioni globali
+ */
+export class LocalizationService {
+    /**
+     * Costruttore
+     *
+     * @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(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;
+            this.SmallLocale = LocaleDefinitions.getByAlias(lr).smallVersion;
+        });
+    }
+    /**
+     * Genera un nuovo servizio di localizzazione data una classe in modo che le localizzazioni non siano più solo da provide-are a livello di componente, ma possano
+     * anche essere create al volo dal componente/servizio/qualsiasicosa che le deve utilizzare
+     *
+     * @param {Type<LocalizationService>} lcst Classe da usare per crare il nuovo servizio di localizzazione
+     */
+    generateFromType(lcst) {
+        const injector = Injector.create({
+            providers: [
+                { provide: LOC_MISSING_POLICY, useValue: this.onMissing },
+                { provide: BaseLocalization, useValue: this.baseLocalization },
+                { provide: LocalePersistor, useValue: this.LocalePersistor },
+                { provide: LocalizationService, useClass: lcst }
+            ]
+        });
+        return injector.get(LocalizationService);
+    }
+    /**
+     * Imposta la localizzazione di un token all'interno della **TranslationCache**
+     *
+     * @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} token Nome del token
+     * @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**
+     */
+    setToken(direction, token, left, right) {
+        this.Persistor.setToken(direction, token, left, right);
+    }
+    /**
+     * Imposta la localizzazione di una frase all'interno della **TranslationCache**
+     *
+     * @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**
+     */
+    set(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)) {
+            if (this.onMissing != LocalizationMissingPolicy.PrintSourceWithoutWarnings)
+                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
+     *
+     * @param {string} text Il token da localizzare
+     *
+     * @returns {string} Token localizzato
+     */
+    token(text) {
+        return this.loc(text, true);
+    }
+    /**
+     * Localizza una frase
+     *
+     * @param {string} text Frase da localizzare
+     * @param {boolean} allowtokens Indica se la frase **text** potrebbe essere un token o no
+     *
+     * @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 "";
+        // Prendo la localizzazione o dalla cache attuale o dalla cache del servizio base
+        var item = this.Persistor.get(text, allowtokens) || this.baseLocalization.Persistor.get(text, allowtokens);
+        if (!item) {
+            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.PrintSourceWithoutWarnings:
+                    return text;
+                case LocalizationMissingPolicy.ThrowException:
+                    throw message;
+            }
+        }
+        var loc = this.Persistor.translationByCulture(item, this.Locale);
+        if (!loc) {
+            console.error("Impossibile trovare la localizzazione per '" + text + "', culture " + this.Locale);
+            return "";
+        }
+        return loc.translation;
+    }
+    async changeLocale(newLocale) {
+        let locale = await this.LocalePersistor.recover().toPromise();
+        if (newLocale == locale) {
+            console.info("Il locale richiesto è lo stesso del locale attuale. Ignoro l'operazione");
+            return;
+        }
+        else {
+            await this.LocalePersistor.persist(newLocale).toPromise();
+            location.reload();
+        }
+    }
+}
+LocalizationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LocalizationService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+LocalizationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LocalizationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LocalizationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"localizations.service.js","sourceRoot":"","sources":["../../../../projects/localizations/src/lib/localizations.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAQ,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAE5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;;AAE/D;;GAEG;AAEH,MAAM,OAAO,mBAAmB;IAe5B;;;;;;OAMG;IACH,YAAoB,QAAkB;QAAlB,aAAQ,GAAR,QAAQ,CAAU;QApBtC;;WAEG;QACK,qBAAgB,GAAuC,EAAE,CAAC;QAkB9D,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAC1D,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;QAC5D,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QAEvD,IAAI,CAAC,SAAS,GAAG,IAAI,qBAAqB,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAElE,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE;YACxC,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;YACjB,IAAI,CAAC,WAAW,GAAG,iBAAiB,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,YAAY,CAAC;QACrE,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;;;;OAKG;IACI,gBAAgB,CAAC,IAA+B;QACnD,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC;YAC7B,SAAS,EAAE;gBACP,EAAE,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,IAAI,CAAC,SAAS,EAAC;gBACxD,EAAE,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,IAAI,CAAC,gBAAgB,EAAC;gBAC7D,EAAE,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,IAAI,CAAC,eAAe,EAAC;gBAC3D,EAAE,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,IAAI,EAAE;aACnD;SACJ,CAAC,CAAC;QACH,OAAO,QAAQ,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;;;;;OASG;IACO,QAAQ,CAAC,SAAiB,EAAE,KAAa,EAAE,IAAY,EAAE,KAAe;QAC9E,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;;;;OAQG;IACO,GAAG,CAAC,SAAiB,EAAE,IAAY,EAAE,KAAe;QAC1D,qFAAqF;QACrF,2HAA2H;QAC3H,IAAI,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE;YAClD,IAAG,IAAI,CAAC,SAAS,IAAK,yBAAyB,CAAC,0BAA0B;gBACtE,OAAO,CAAC,IAAI,CAAC,yBAAyB,IAAI,iEAAiE,CAAC,CAAC;YACjH,OAAO;SACV;QACD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,IAAY;QACrB,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAChC,CAAC;IAED;;;;;;;OAOG;IACI,GAAG,CAAC,IAAY,EAAE,WAAqB;QAC1C,IAAI,CAAC,IAAI,CAAC,MAAM;YACZ,MAAM,2HAA2H,CAAC;QAEtI,IAAI,CAAC,IAAI,IAAI,IAAI,IAAI,WAAW;YAC5B,OAAO,EAAE,CAAC;QAEd,iFAAiF;QACjF,IAAI,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,WAAW,CAAC,IAAI,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;QAC3G,IAAI,CAAC,IAAI,EAAE;YACP,IAAI,OAAO,GAAG,8CAA8C,IAAI,GAAG,CAAC;YACpE,QAAQ,IAAI,CAAC,SAAS,EAAE;gBACpB,KAAK,yBAAyB,CAAC,UAAU;oBACrC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;oBACvB,OAAO,EAAE,CAAC;gBACd,KAAK,yBAAyB,CAAC,WAAW;oBACtC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;oBACtB,OAAO,IAAI,CAAC;gBAChB,KAAK,yBAAyB,CAAC,0BAA0B;oBACrD,OAAO,IAAI,CAAC;gBAChB,KAAK,yBAAyB,CAAC,cAAc;oBACzC,MAAM,OAAO,CAAC;aACrB;SACJ;QAED,IAAI,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACjE,IAAI,CAAC,GAAG,EAAE;YACN,OAAO,CAAC,KAAK,CAAC,6CAA6C,GAAG,IAAI,GAAG,aAAa,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;YAClG,OAAO,EAAE,CAAC;SACb;QAED,OAAO,GAAG,CAAC,WAAW,CAAC;IAC3B,CAAC;IAEM,KAAK,CAAC,YAAY,CAAC,SAAiB;QACvC,IAAI,MAAM,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,CAAC;QAC9D,IAAI,SAAS,IAAI,MAAM,EAAE;YACrB,OAAO,CAAC,IAAI,CAAC,yEAAyE,CAAC,CAAC;YACxF,OAAO;SACV;aACI;YACD,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,SAAS,EAAE,CAAC;YAC1D,QAAQ,CAAC,MAAM,EAAE,CAAC;SACrB;IACL,CAAC;;gHAtJQ,mBAAmB;oHAAnB,mBAAmB;2FAAnB,mBAAmB;kBAD/B,UAAU","sourcesContent":["import { Injectable, Injector, Type } from '@angular/core';\r\nimport { BaseLocalization } from './core/localization.base';\r\nimport { ItemLocalization } from './models/ItemLocalization';\r\nimport { LocalizationPersistor } from './core/localization.persistor';\r\nimport { LocalePersistor } from './locale-persistor/LocalePersistor';\r\nimport { LOC_MISSING_POLICY } from './tokens';\r\nimport { LocalizationMissingPolicy } from './models/LocalizationMissingPolicy';\r\nimport { LocaleDefinitions } from './models/LocaleDefinitions';\r\n\r\n/**\r\n * Classe di localizzazione estendibile che permette di specificare le proprie localizzazioni e comunque rendere disponibili le localizzazioni globali\r\n */\r\n@Injectable()\r\nexport class LocalizationService {\r\n\r\n    /**\r\n     * Cache di tutte le localizzazioni disonibili all'interno di questa classe\r\n     */\r\n    private TranslationCache: { [id: string]: ItemLocalization } = {};\r\n\r\n    public Locale: string;\r\n    public SmallLocale: string;\r\n\r\n    private baseLocalization: BaseLocalization;\r\n    private onMissing: LocalizationMissingPolicy\r\n    private Persistor: LocalizationPersistor;\r\n    private LocalePersistor: LocalePersistor;\r\n\r\n    /**\r\n     * Costruttore\r\n     * \r\n     * @param {string} Locale Locale da utilizzare nel momento che questo servizio richiede le traduzioni\r\n     * @param {baseLocalization} baseLocalization Classe base di localizzazione già fornita a livello di root dalla libreria stessa. \r\n     * È sufficiente iniettarla nell'eventuale costruttore che estende questa classe e passarla as-is\r\n     */\r\n    constructor(private injector: Injector) {\r\n        this.LocalePersistor = this.injector.get(LocalePersistor);\r\n        this.baseLocalization = this.injector.get(BaseLocalization);\r\n        this.onMissing = this.injector.get(LOC_MISSING_POLICY);\r\n\r\n        this.Persistor = new LocalizationPersistor(this.TranslationCache);\r\n\r\n        this.baseLocalization.Locale.subscribe(lr => {\r\n            this.Locale = lr;\r\n            this.SmallLocale = LocaleDefinitions.getByAlias(lr).smallVersion;\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Genera un nuovo servizio di localizzazione data una classe in modo che le localizzazioni non siano più solo da provide-are a livello di componente, ma possano\r\n     * anche essere create al volo dal componente/servizio/qualsiasicosa che le deve utilizzare\r\n     * \r\n     * @param {Type<LocalizationService>} lcst Classe da usare per crare il nuovo servizio di localizzazione\r\n     */\r\n    public generateFromType(lcst: Type<LocalizationService>): LocalizationService {\r\n        const injector = Injector.create({\r\n            providers: [\r\n                { provide: LOC_MISSING_POLICY, useValue: this.onMissing},\r\n                { provide: BaseLocalization, useValue: this.baseLocalization},\r\n                { provide: LocalePersistor, useValue: this.LocalePersistor},\r\n                { provide: LocalizationService, useClass: lcst }\r\n            ]\r\n        });\r\n        return injector.get(LocalizationService);\r\n    }\r\n\r\n    /**\r\n     * Imposta la localizzazione di un token all'interno della **TranslationCache**\r\n     * \r\n     * @param {string} direction Direzione della traduzione, rappresenta la lingua base in cui aspettarsi il testo e le varie lingue in cui viene tradotta.\r\n     * Ad esempio, \"en->it\" indica che il parametro **left** è valido per le localizzazioni in inglese, mentre nell'elemento 0 del parametro **right** \r\n     * è 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\"\r\n     * @param {string} token Nome del token\r\n     * @param {string} left Valore del token per la lingua specificata nel lato immediatamente sinistro alla freccia del parametro **direction**\r\n     * @param {string} right Array con i valori facenti riferimento all'N-esima lingua del lato destro del parametro **direction**\r\n     */\r\n    protected setToken(direction: string, token: string, left: string, right: string[]) {\r\n        this.Persistor.setToken(direction, token, left, right);\r\n    }\r\n\r\n    /**\r\n     * Imposta la localizzazione di una frase all'interno della **TranslationCache**\r\n     * \r\n     * @param {string} direction Direzione della traduzione, rappresenta la lingua base in cui aspettarsi il testo e le varie lingue in cui viene tradotta.\r\n     * Ad esempio, \"en->it\" indica che il parametro **left** è valido per le localizzazioni in inglese, mentre nell'elemento 0 del parametro **right** \r\n     * è 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\"\r\n     * @param {string} left Valore della frase per la lingua specificata nel lato immediatamente sinistro alla freccia del parametro **direction**\r\n     * @param {string} right Array con i valori facenti riferimento all'N-esima lingua del lato destro del parametro **direction**\r\n     */\r\n    protected set(direction: string, left: string, right: string[]) {\r\n        // Controlla di non reinserire la stessa localizzazione presente nel BaseLocalization\r\n        // i controlli per il non reinserimento della stessa localizzazione all'interno della stessa istanza è fatto lato Persistor\r\n        if (this.baseLocalization.Persistor.get(left, false)) {\r\n            if(this.onMissing !=  LocalizationMissingPolicy.PrintSourceWithoutWarnings)\r\n                console.warn(`La localizzazione per ${left} è già presente fra le localizzazioni base, ignoro l'operazione`);\r\n            return;\r\n        }\r\n        this.Persistor.set(direction, left, right);\r\n    }\r\n\r\n    /**\r\n     * Localizza un token\r\n     * \r\n     * @param {string} text Il token da localizzare\r\n     * \r\n     * @returns {string} Token localizzato\r\n     */\r\n    public token(text: string): string {\r\n        return this.loc(text, true);\r\n    }\r\n\r\n    /**\r\n     * Localizza una frase\r\n     * \r\n     * @param {string} text Frase da localizzare\r\n     * @param {boolean} allowtokens Indica se la frase **text** potrebbe essere un token o no\r\n     * \r\n     * @returns {string} Frase localizzata\r\n     */\r\n    public loc(text: string, allowtokens?: boolean): string {\r\n        if (!this.Locale)\r\n            throw \"Il sistema di localizzazione non ha ancora caricato il Locale, assicurarsi di caricare l'APP solo al retrieve del locale'\";\r\n\r\n        if (!text || text == \"undefined\")\r\n            return \"\";\r\n\r\n        // Prendo la localizzazione o dalla cache attuale o dalla cache del servizio base\r\n        var item = this.Persistor.get(text, allowtokens) || this.baseLocalization.Persistor.get(text, allowtokens);\r\n        if (!item) {\r\n            let message = `Impossibile trovare la localizzazione per '${text}'`;\r\n            switch (this.onMissing) {\r\n                case LocalizationMissingPolicy.PrintEmpty:\r\n                    console.error(message);\r\n                    return \"\";\r\n                case LocalizationMissingPolicy.PrintSource:\r\n                    console.warn(message);\r\n                    return text;\r\n                case LocalizationMissingPolicy.PrintSourceWithoutWarnings:\r\n                    return text;\r\n                case LocalizationMissingPolicy.ThrowException:\r\n                    throw message;\r\n            }\r\n        }\r\n\r\n        var loc = this.Persistor.translationByCulture(item, this.Locale);\r\n        if (!loc) {\r\n            console.error(\"Impossibile trovare la localizzazione per '\" + text + \"', culture \" + this.Locale);\r\n            return \"\";\r\n        }\r\n\r\n        return loc.translation;\r\n    }\r\n\r\n    public async changeLocale(newLocale: string) {\r\n        let locale = await this.LocalePersistor.recover().toPromise();\r\n        if (newLocale == locale) {\r\n            console.info(\"Il locale richiesto è lo stesso del locale attuale. Ignoro l'operazione\");\r\n            return;\r\n        }\r\n        else {\r\n            await this.LocalePersistor.persist(newLocale).toPromise();\r\n            location.reload();\r\n        }\r\n    }\r\n}"]}

package/esm2020/lib/models/BaseLocalizationTokens.mjs

@@ -0,0 +1,14 @@
+export 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 = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQmFzZUxvY2FsaXphdGlvblRva2Vucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2xvY2FsaXphdGlvbnMvc3JjL2xpYi9tb2RlbHMvQmFzZUxvY2FsaXphdGlvblRva2Vucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxNQUFNLENBQU4sSUFBWSxzQkFXWDtBQVhELFdBQVksc0JBQXNCO0lBQzlCLHVFQUE2QyxDQUFBO0lBQzdDLHFGQUEyRCxDQUFBO0lBQzNELGlEQUF1QixDQUFBO0lBQ3ZCLG1FQUF5QyxDQUFBO0lBQ3pDLHVFQUE2QyxDQUFBO0lBQzdDLGlGQUF1RCxDQUFBO0lBQ3ZELGlFQUF1QyxDQUFBO0lBQ3ZDLCtFQUFxRCxDQUFBO0lBQ3JELG1GQUF5RCxDQUFBO0lBQ3pELGlHQUF1RSxDQUFBO0FBQzNFLENBQUMsRUFYVyxzQkFBc0IsS0FBdEIsc0JBQXNCLFFBV2pDIiwic291cmNlc0NvbnRlbnQiOlsiXHJcbmV4cG9ydCBlbnVtIEJhc2VMb2NhbGl6YXRpb25Ub2tlbnMge1xyXG4gICAgZ2V0RGF0ZU1vbnRoUG9zaXRpb24gPSBcImdldERhdGVNb250aFBvc2l0aW9uXCIsXHJcbiAgICBnZXREaXNwbGF5RGF0ZU1vbnRoUG9zaXRpb24gPSBcImdldERpc3BsYXlEYXRlTW9udGhQb3NpdGlvblwiLFxyXG4gICAgZ2V0TG9jYWxlID0gXCJnZXRMb2NhbGVcIixcclxuICAgIGdldFNtYWxsRGF0ZUZvcm1hdCA9IFwiZ2V0U21hbGxEYXRlRm9ybWF0XCIsXHJcbiAgICBnZXREZWZhdWx0RGF0ZUZvcm1hdCA9IFwiZ2V0RGVmYXVsdERhdGVGb3JtYXRcIixcclxuICAgIGdldFNtYWxsRGF0ZURpc3BsYXlGb3JtYXQgPSBcImdldFNtYWxsRGF0ZURpc3BsYXlGb3JtYXRcIixcclxuICAgIGdldEZ1bGxEYXRlRm9ybWF0ID0gXCJnZXRGdWxsRGF0ZUZvcm1hdFwiLFxyXG4gICAgZ2V0RnVsbERhdGVEaXNwbGF5Rm9ybWF0ID0gXCJnZXRGdWxsRGF0ZURpc3BsYXlGb3JtYXRcIixcclxuICAgIGdldEZ1bGxEYXRlRm9ybWF0Tm9TZWNvbmRzID0gXCJnZXRGdWxsRGF0ZUZvcm1hdE5vU2Vjb25kc1wiLFxyXG4gICAgZ2V0RnVsbERhdGVEaXNwbGF5Rm9ybWF0Tm9TZWNvbmRzID0gXCJnZXRGdWxsRGF0ZURpc3BsYXlGb3JtYXROb1NlY29uZHNcIlxyXG59XHJcbiJdfQ==

package/esm2020/lib/models/ItemLocalization.mjs

@@ -0,0 +1,18 @@
+/**
+ * Contenitore delle localizzazioni collegate ad un testo "base", una per ogni linguaggio supportato
+ */
+export class ItemLocalization {
+    /**
+     * Costruttore
+     *
+     * @param {boolean} token Indica se è un token o se è un testo
+     * @param {string} baseText Testo base che verrà richiesto quando verrà cercata la localizzazione
+     * @param {SpecializedLocalization[]} translations Lista di traduzioni in base al testo base
+     */
+    constructor(token, baseText, translations) {
+        this.token = token;
+        this.baseText = baseText;
+        this.translations = translations;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSXRlbUxvY2FsaXphdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2xvY2FsaXphdGlvbnMvc3JjL2xpYi9tb2RlbHMvSXRlbUxvY2FsaXphdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7R0FFRztBQUNILE1BQU0sT0FBTyxnQkFBZ0I7SUFFM0I7Ozs7OztPQU1HO0lBQ0gsWUFBbUIsS0FBYyxFQUFTLFFBQWdCLEVBQVMsWUFBdUM7UUFBdkYsVUFBSyxHQUFMLEtBQUssQ0FBUztRQUFTLGFBQVEsR0FBUixRQUFRLENBQVE7UUFBUyxpQkFBWSxHQUFaLFlBQVksQ0FBMkI7SUFBRyxDQUFDO0NBQy9HIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU3BlY2lhbGl6ZWRMb2NhbGl6YXRpb24gfSBmcm9tIFwiLi9TcGVjaWFsaXplZExvY2FsaXphdGlvblwiO1xyXG5cclxuLyoqXHJcbiAqIENvbnRlbml0b3JlIGRlbGxlIGxvY2FsaXp6YXppb25pIGNvbGxlZ2F0ZSBhZCB1biB0ZXN0byBcImJhc2VcIiwgdW5hIHBlciBvZ25pIGxpbmd1YWdnaW8gc3VwcG9ydGF0b1xyXG4gKi9cclxuZXhwb3J0IGNsYXNzIEl0ZW1Mb2NhbGl6YXRpb24ge1xyXG5cclxuICAvKipcclxuICAgKiBDb3N0cnV0dG9yZVxyXG4gICAqIFxyXG4gICAqIEBwYXJhbSB7Ym9vbGVhbn0gdG9rZW4gSW5kaWNhIHNlIMOoIHVuIHRva2VuIG8gc2Ugw6ggdW4gdGVzdG9cclxuICAgKiBAcGFyYW0ge3N0cmluZ30gYmFzZVRleHQgVGVzdG8gYmFzZSBjaGUgdmVycsOgIHJpY2hpZXN0byBxdWFuZG8gdmVycsOgIGNlcmNhdGEgbGEgbG9jYWxpenphemlvbmVcclxuICAgKiBAcGFyYW0ge1NwZWNpYWxpemVkTG9jYWxpemF0aW9uW119IHRyYW5zbGF0aW9ucyBMaXN0YSBkaSB0cmFkdXppb25pIGluIGJhc2UgYWwgdGVzdG8gYmFzZVxyXG4gICAqL1xyXG4gIGNvbnN0cnVjdG9yKHB1YmxpYyB0b2tlbjogYm9vbGVhbiwgcHVibGljIGJhc2VUZXh0OiBzdHJpbmcsIHB1YmxpYyB0cmFuc2xhdGlvbnM6IFNwZWNpYWxpemVkTG9jYWxpemF0aW9uW10peyB9XHJcbn0iXX0=

package/esm2020/lib/models/LocaleDefinitions.mjs

@@ -0,0 +1,26 @@
+import { LocaleObject } from "./LocaleObject";
+/** Classe che gestisce le definizioni dei locali disponibili */
+export class LocaleDefinitions {
+    /** @ignore Costruttore */
+    constructor() { }
+    /**
+     * In base a un alias restituisce il locale rappresentato
+     *
+     * @param {string} alias Alias in base al quale raccogliere il Locale
+     *
+     * @returns {LocaleObject} Locale richiesto dall'alias
+     */
+    static getByAlias(alias) {
+        if (!this.LocaleCache[alias])
+            this.LocaleCache[alias] = this.AvailableLocales.find(t => !!t.aliases.find(a => a == alias));
+        return this.LocaleCache[alias];
+    }
+}
+/** Cache per ottimizzare la chiamata **getByAlias** */
+LocaleDefinitions.LocaleCache = {};
+/** Lista dei locali disponibili, definiti anche con i vari alias */
+LocaleDefinitions.AvailableLocales = [
+    new LocaleObject('it-IT', 'Italiano', ['it', 'it-IT'], "it"),
+    new LocaleObject('en-US', 'English', ['en', 'en-US'], "en")
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/models/LocaleObject.mjs

@@ -0,0 +1,20 @@
+/**
+ * Classe che rappresenta un locale (Es. 'Italiano') con i propri alias (Es. 'it' oppure 'it-IT')
+ */
+export class LocaleObject {
+    /**
+     * Costruttore
+     *
+     * @param {string} id Codice locale
+     * @param {string} description Descrizione locale
+     * @param {string[]} aliases Alias con cui quel locale è conosciuto
+     * @param {string} smallVersion Versione standard "small" del locale. Es. "it-IT" -> "it"
+     */
+    constructor(id, description, aliases, smallVersion) {
+        this.id = id;
+        this.description = description;
+        this.aliases = aliases;
+        this.smallVersion = smallVersion;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9jYWxlT2JqZWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbG9jYWxpemF0aW9ucy9zcmMvbGliL21vZGVscy9Mb2NhbGVPYmplY3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0E7O0dBRUc7QUFDSCxNQUFNLE9BQU8sWUFBWTtJQUVyQjs7Ozs7OztPQU9HO0lBQ0gsWUFBbUIsRUFBVSxFQUFTLFdBQW1CLEVBQVMsT0FBaUIsRUFBUyxZQUFvQjtRQUE3RixPQUFFLEdBQUYsRUFBRSxDQUFRO1FBQVMsZ0JBQVcsR0FBWCxXQUFXLENBQVE7UUFBUyxZQUFPLEdBQVAsT0FBTyxDQUFVO1FBQVMsaUJBQVksR0FBWixZQUFZLENBQVE7SUFBSSxDQUFDO0NBQ3hIIiwic291cmNlc0NvbnRlbnQiOlsiXHJcbi8qKlxyXG4gKiBDbGFzc2UgY2hlIHJhcHByZXNlbnRhIHVuIGxvY2FsZSAoRXMuICdJdGFsaWFubycpIGNvbiBpIHByb3ByaSBhbGlhcyAoRXMuICdpdCcgb3BwdXJlICdpdC1JVCcpXHJcbiAqL1xyXG5leHBvcnQgY2xhc3MgTG9jYWxlT2JqZWN0IHtcclxuXHJcbiAgICAvKipcclxuICAgICAqIENvc3RydXR0b3JlXHJcbiAgICAgKiBcclxuICAgICAqIEBwYXJhbSB7c3RyaW5nfSBpZCBDb2RpY2UgbG9jYWxlXHJcbiAgICAgKiBAcGFyYW0ge3N0cmluZ30gZGVzY3JpcHRpb24gRGVzY3JpemlvbmUgbG9jYWxlXHJcbiAgICAgKiBAcGFyYW0ge3N0cmluZ1tdfSBhbGlhc2VzIEFsaWFzIGNvbiBjdWkgcXVlbCBsb2NhbGUgw6ggY29ub3NjaXV0b1xyXG4gICAgICogQHBhcmFtIHtzdHJpbmd9IHNtYWxsVmVyc2lvbiBWZXJzaW9uZSBzdGFuZGFyZCBcInNtYWxsXCIgZGVsIGxvY2FsZS4gRXMuIFwiaXQtSVRcIiAtPiBcIml0XCJcclxuICAgICAqL1xyXG4gICAgY29uc3RydWN0b3IocHVibGljIGlkOiBzdHJpbmcsIHB1YmxpYyBkZXNjcmlwdGlvbjogc3RyaW5nLCBwdWJsaWMgYWxpYXNlczogc3RyaW5nW10sIHB1YmxpYyBzbWFsbFZlcnNpb246IHN0cmluZykgeyB9XHJcbn1cclxuIl19

package/esm2020/lib/models/LocalizationMissingPolicy.mjs

@@ -0,0 +1,12 @@
+/**
+ * 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
+ */
+export var LocalizationMissingPolicy;
+(function (LocalizationMissingPolicy) {
+    LocalizationMissingPolicy[LocalizationMissingPolicy["PrintEmpty"] = 0] = "PrintEmpty";
+    LocalizationMissingPolicy[LocalizationMissingPolicy["PrintSource"] = 1] = "PrintSource";
+    LocalizationMissingPolicy[LocalizationMissingPolicy["PrintSourceWithoutWarnings"] = 2] = "PrintSourceWithoutWarnings";
+    LocalizationMissingPolicy[LocalizationMissingPolicy["ThrowException"] = 3] = "ThrowException";
+})(LocalizationMissingPolicy || (LocalizationMissingPolicy = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9jYWxpemF0aW9uTWlzc2luZ1BvbGljeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2xvY2FsaXphdGlvbnMvc3JjL2xpYi9tb2RlbHMvTG9jYWxpemF0aW9uTWlzc2luZ1BvbGljeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQTs7O0dBR0c7QUFDSCxNQUFNLENBQU4sSUFBWSx5QkFLWDtBQUxELFdBQVkseUJBQXlCO0lBQ25DLHFGQUFVLENBQUE7SUFDVix1RkFBVyxDQUFBO0lBQ1gscUhBQTBCLENBQUE7SUFDMUIsNkZBQWMsQ0FBQTtBQUNoQixDQUFDLEVBTFcseUJBQXlCLEtBQXpCLHlCQUF5QixRQUtwQyIsInNvdXJjZXNDb250ZW50IjpbIlxyXG4vKiogXHJcbiAqIEVudW0gY2hlIHJhcHByZXNlbnRhIGxlIHBvbGljeSBkaSBjb21wb3J0YW1lbnRvIHF1YWxvcmUgaWwgc2lzdGVtYSBkaSBsb2NhbGl6emF6aW9uZSBub24gdHJvdmkgbGEgbG9jYWxpenphemlvbmUgY2VyY2F0YSwgXHJcbiAqIHVzYXJlICoqVGhyb3dFeGNlcHRpb24qKiBzb2xvIHNlIGNpIHNpIHNlbnRlIGluZmFsbGliaWxpIG8gc2kgdnVvbGUgZGVidWdnYXJlIGluIG1hbmllcmEgYXBwcm9mb25kaXRhIGwnYXBwbGljYXppb25lIFxyXG4gKi9cclxuZXhwb3J0IGVudW0gTG9jYWxpemF0aW9uTWlzc2luZ1BvbGljeSB7XHJcbiAgUHJpbnRFbXB0eSxcclxuICBQcmludFNvdXJjZSxcclxuICBQcmludFNvdXJjZVdpdGhvdXRXYXJuaW5ncyxcclxuICBUaHJvd0V4Y2VwdGlvblxyXG59XHJcbiJdfQ==