@esfaenza/localizations 12.2.10 → 13.1.2

package/esfaenza-localizations.d.ts

@@ -1,5 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
+/// <amd-module name="@esfaenza/localizations" />
 export * from './public-api';
-export { BaseLocalization as ɵa } from './lib/core/localization.base';

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,177 @@
+import { Injectable } from "@angular/core";
+import { ItemLocalization, LocaleDefinitions, SpecializedLocalization } from "../models";
+import * as i0 from "@angular/core";
+/**
+ * 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() {
+        /**
+         * 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"]);
+    }
+    /**
+     * 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"
+     * @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**
+     */
+    static setToken(locCache, 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);
+        to.forEach((t, index) => {
+            let localeTo = LocaleDefinitions.getByAlias(t);
+            BaseLocalization._set(locCache, 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) {
+        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);
+        to.forEach((t, index) => {
+            let localeTo = LocaleDefinitions.getByAlias(t);
+            BaseLocalization._set(locCache, 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);
+        if (!item) {
+            locCache[text] = new ItemLocalization(token, text, [new SpecializedLocalization(culture, translation)]);
+            return;
+        }
+        var trs = BaseLocalization.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 {{ [id: string]: ItemLocalization }} locCache Cache all'interno del quale cercare il **text**
+     * @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;
+        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
+     */
+    static 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;
+    }
+}
+BaseLocalization.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BaseLocalization, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+BaseLocalization.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BaseLocalization });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BaseLocalization, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# 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 { Injectable } from \"@angular/core\";\r\nimport { ItemLocalization, LocaleDefinitions, SpecializedLocalization } from \"../models\";\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()\r\nexport class BaseLocalization {\r\n\r\n    /**\r\n     * Cache di tutte le localizzazioni di base\r\n     */\r\n    public BaseTranslations: { [id: string]: ItemLocalization } = {};\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() {\r\n        // Odio sprecare caratteri... soprattutto quando rischio che non vengano minificati\r\n        let bt = this.BaseTranslations;\r\n        let bl = BaseLocalization;\r\n\r\n        bl.set(bt, \"en->it\", \"Remove\", [\"Elimina\"]);\r\n        bl.set(bt, \"en->it\", \"Paging\", [\"Paginazione\"]);\r\n        bl.set(bt, \"en->it\", \"Yes\", [\"Si\"]);\r\n        bl.set(bt, \"en->it\", \"No\", [\"No\"]);\r\n        bl.set(bt, \"en->it\", \"YES\", [\"SI'\"]);\r\n        bl.set(bt, \"en->it\", \"NO\", [\"NO\"]);\r\n        bl.set(bt, \"en->it\", \"Found objects\", [\"Risultati trovati\"]);\r\n        bl.set(bt, \"en->it\", \"Loading data...\", [\"Carico i dati...\"]);\r\n        bl.set(bt, \"en->it\", \"Error during save operations\", [\"Errori durante il salvataggio\"]);\r\n        bl.set(bt, \"en->it\", \"Error\", [\"Errore\"]);\r\n        bl.set(bt, \"en->it\", \"Warning\", [\"Avviso\"]);\r\n        bl.set(bt, \"en->it\", \"Information\", [\"Informazione\"]);\r\n        bl.set(bt, \"en->it\", \"Save\", [\"Salva\"]);\r\n        bl.set(bt, \"en->it\", \"Back\", [\"Indietro\"]);\r\n        bl.set(bt, \"en->it\", \"From\", [\"Da\"]);\r\n        bl.set(bt, \"en->it\", \"To\", [\"A\"]);\r\n        bl.set(bt, \"en->it\", \"View Chart\", [\"Vedi Grafico\"]);\r\n        bl.set(bt, \"en->it\", \"View Table\", [\"Vedi Tabella\"]);\r\n        bl.set(bt, \"en->it\", \"Notes\", [\"Note\"]);\r\n        bl.set(bt, \"en->it\", \"Edit Notes\", [\"Modifica Note\"]);\r\n        bl.set(bt, \"en->it\", \"Cancel\", [\"Annulla\"]);\r\n        bl.set(bt, \"en->it\", \"Confirm\", [\"Conferma\"]);\r\n        bl.set(bt, \"en->it\", \"View\", [\"Visualizza\"]);\r\n        bl.set(bt, \"en->it\", \"Close\", [\"Chiudi\"]);\r\n        bl.set(bt, \"en->it\", \"Select\", [\"Seleziona\"]);\r\n        bl.set(bt, \"en->it\", \"Meter Reading registered successfully\", [\"Lettura registrata correttamente\"]);\r\n        bl.set(bt, \"en->it\", \"Validation errors during save operations\", [\"Errori di validazione durante il salvataggio\"]);\r\n        bl.set(bt, \"en->it\", \"Can't register reading\", [\"Impossibile registrare la lettura\"]);\r\n        bl.set(bt, \"en->it\", \"Electricity\", [\"Elettricita\"]);\r\n        bl.set(bt, \"en->it\", \"Gas\", [\"Gas\"]);\r\n        bl.set(bt, \"en->it\", \"Water\", [\"Acqua\"]);\r\n        bl.set(bt, \"en->it\", \"Delete\", [\"Elimina\"]);\r\n        bl.set(bt, \"en->it\", \"This operation cannot be reverted\", [\"Questa operazione non puo' essere annullata\"]);\r\n        bl.set(bt, \"en->it\", \"Hide\", [\"Nascondi\"]);\r\n\r\n        // Helper validazione\r\n        bl.set(bt, \"en->it\", \"Required field\", [\"Campo richiesto\"]);\r\n        bl.set(bt, \"en->it\", \"Wrong field format\", [\"Formato campo errato\"]);\r\n        bl.set(bt, \"en->it\", \"Wrong field format or field missing\", [\"Formato campo errato o campo mancante\"]);\r\n        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\"]);\r\n\r\n        // Informazioni sulle date\r\n        bl.setToken(bt, \"en->it\", \"getDateMonthPosition\", \"0\", [\"1\"]);\r\n        bl.setToken(bt, \"en->it\", \"getDisplayDateMonthPosition\", \"1\", [\"1\"]);\r\n        bl.setToken(bt, \"en->it\", \"getLocale\", \"en-US\", [\"it-IT\"]);\r\n        bl.setToken(bt, \"en->it\", \"getSmallDateFormat\", \"MM/DD/YYYY\", [\"DD/MM/YYYY\"]);\r\n        bl.setToken(bt, \"en->it\", \"getDefaultDateFormat\", \"MM/DD/YYYY\", [\"MM/DD/YYYY\"]);\r\n        bl.setToken(bt, \"en->it\", \"getSmallDateDisplayFormat\", \"DD/MM/YYYY\", [\"DD/MM/YYYY\"]);\r\n        bl.setToken(bt, \"en->it\", \"getFullDateFormat\", \"MM/DD/YYYY HH:mm:ss\", [\"DD/MM/YYYY HH:mm:ss\"]);\r\n        bl.setToken(bt, \"en->it\", \"getFullDateDisplayFormat\", \"DD/MM/YYYY HH:mm:ss\", [\"DD/MM/YYYY HH:mm:ss\"]);\r\n        bl.setToken(bt, \"en->it\", \"getFullDateFormatNoSeconds\", \"MM/DD/YYYY HH:mm\", [\"DD/MM/YYYY HH:mm\"]);\r\n        bl.setToken(bt, \"en->it\", \"getFullDateDisplayFormatNoSeconds\", \"DD/MM/YYYY HH:mm\", [\"DD/MM/YYYY HH:mm\"]);\r\n    }\r\n\r\n    /**\r\n     * Imposta la localizzazione di un token all'interno della cache scelta\r\n     * \r\n     * @param {{ [id: string]: ItemLocalization }} locCache Cache all'interno della quale inserire l'informazione del token con le localizzazioni\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 static setToken(locCache: { [id: string]: ItemLocalization }, 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        BaseLocalization._set(locCache, token, localeFrom.id, left, true);\r\n\r\n        to.forEach((t, index) => {\r\n            let localeTo = LocaleDefinitions.getByAlias(t);\r\n            BaseLocalization._set(locCache, 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 {{ [id: string]: ItemLocalization }} locCache Cache all'interno della quale inserire l'informazione della frase con le localizzazioni\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 static set(locCache: { [id: string]: ItemLocalization }, 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        BaseLocalization._set(locCache, left, localeFrom.id, left);\r\n\r\n        to.forEach((t, index) => {\r\n            let localeTo = LocaleDefinitions.getByAlias(t);\r\n            BaseLocalization._set(locCache, 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 {{ [id: string]: ItemLocalization }} locCache Cache all'interno della quale inserire l'informazione del testo con le localizzazioni\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 static _set(locCache: { [id: string]: ItemLocalization }, text: string, culture: string, translation: string, token?: boolean) {\r\n        let item = BaseLocalization.findByText(locCache, text, token);\r\n        if (!item) {\r\n            locCache[text] = new ItemLocalization(token, text, [new SpecializedLocalization(culture, translation)]);\r\n            return;\r\n        }\r\n\r\n        var trs = BaseLocalization.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 {{ [id: string]: ItemLocalization }} locCache Cache all'interno del quale cercare il **text**\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 static findByText(locCache: { [id: string]: ItemLocalization }, text: string, allowtokens: boolean): ItemLocalization {\r\n        let possibleItem: ItemLocalization = locCache[text];\r\n        if (!possibleItem)\r\n            return null;\r\n\r\n        var item = 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 static 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/localizations.module.mjs

@@ -0,0 +1,30 @@
+import { NgModule } from '@angular/core';
+import { LOC_LOCALE } from './tokens';
+import { LocalizationService } from './localizations.service';
+import { LocDatePipe } from './pipes/loc_date.pipe';
+import { LocalizePipe } from './pipes/localize.pipe';
+import { BaseLocalization } from './core/localization.base';
+import * as i0 from "@angular/core";
+export class LocalizationModule {
+    static forRoot(config) {
+        return {
+            ngModule: LocalizationModule,
+            providers: [
+                LocalizationService,
+                BaseLocalization,
+                { provide: LOC_LOCALE, useValue: config?.locale || 'it-IT' }
+            ]
+        };
+    }
+}
+LocalizationModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LocalizationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LocalizationModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LocalizationModule, declarations: [LocalizePipe, LocDatePipe], exports: [LocalizePipe, LocDatePipe] });
+LocalizationModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LocalizationModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LocalizationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [LocalizePipe, LocDatePipe],
+                    exports: [LocalizePipe, LocDatePipe]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/localizations.service.mjs

@@ -0,0 +1,112 @@
+import { Injectable, Inject } from '@angular/core';
+import { LOC_LOCALE } from './tokens';
+import { BaseLocalization } from './core/localization.base';
+import * as i0 from "@angular/core";
+import * as i1 from "./core/localization.base";
+/**
+ * Classe di localizzazione estendibile che permette di specificare le proprie localizzazioni e comunque rendere disponibili le localizzazioni globali
+ */
+export class LocalizationService {
+    /**
+     * Costruttore
+     *
+     * @param {string} baseLoc 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;
+        /**
+         * Cache di tutte le localizzazioni disonibili all'interno di questa classe
+         */
+        this.TranslationCache = {};
+    }
+    /**
+     * 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) {
+        BaseLocalization.setToken(this.TranslationCache, 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) {
+        BaseLocalization.set(this.TranslationCache, 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 (!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);
+        if (!item) {
+            console.error("Couldn't find localization for '" + text + "'");
+            return "";
+        }
+        var loc = BaseLocalization.translationByCulture(item, this.baseLoc);
+        if (!loc) {
+            console.error("Couldn't find localization for '" + text + "', culture " + this.baseLoc);
+            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 "";
+    }
+}
+LocalizationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LocalizationService, deps: [{ token: LOC_LOCALE }, { token: i1.BaseLocalization }], target: i0.ɵɵFactoryTarget.Injectable });
+LocalizationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LocalizationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LocalizationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOC_LOCALE]
+                }] }, { type: i1.BaseLocalization }]; } });
+//# 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,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;;;AAG5D;;GAEG;AAEH,MAAM,OAAO,mBAAmB;IAO5B;;;;;;OAMG;IACH,YAAwC,OAAe,EAAU,gBAAmC;QAA5D,YAAO,GAAP,OAAO,CAAQ;QAAU,qBAAgB,GAAhB,gBAAgB,CAAmB;QAZpG;;WAEG;QACH,qBAAgB,GAAuC,EAAE,CAAC;IAS8C,CAAC;IAEzG;;;;;;;;;OASG;IACO,QAAQ,CAAC,SAAiB,EAAE,KAAa,EAAE,IAAY,EAAE,KAAe;QAC9E,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAgB,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IACpF,CAAC;IAED;;;;;;;;OAQG;IACO,GAAG,CAAC,SAAiB,EAAE,IAAY,EAAE,KAAe;QAC1D,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IACxE,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,IAAI,IAAI,IAAI,WAAW;YAC5B,OAAO,EAAE,CAAC;QAEd,wHAAwH;QACxH,IAAG,IAAI,CAAC,gBAAgB,IAAI,IAAI;YAC5B,IAAI,CAAC,gBAAgB,GAAG,IAAI,gBAAgB,EAAE,CAAC;QAEnD,iFAAiF;QACjF,IAAI,IAAI,GAAG,gBAAgB,CAAC,UAAU,CAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,EAAE,WAAW,CAAC,IAAI,gBAAgB,CAAC,UAAU,CAAC,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;QAC3K,IAAI,CAAC,IAAI,EAAE;YACP,OAAO,CAAC,KAAK,CAAC,kCAAkC,GAAG,IAAI,GAAG,GAAG,CAAC,CAAC;YAC/D,OAAO,EAAE,CAAC;SACb;QAED,IAAI,GAAG,GAAG,gBAAgB,CAAC,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACpE,IAAI,CAAC,GAAG,EAAE;YACN,OAAO,CAAC,KAAK,CAAC,kCAAkC,GAAG,IAAI,GAAG,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;YACxF,OAAO,EAAE,CAAC;SACb;QAED,OAAO,GAAG,CAAC,WAAW,CAAC;IAC3B,CAAC;IAED;;;;;;OAMG;IACI,WAAW,CAAC,IAAY;QAC3B,IAAI,IAAI,IAAI,GAAG;YAAE,OAAO,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC1C,IAAI,IAAI,IAAI,GAAG;YAAE,OAAO,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC5C,IAAI,IAAI,IAAI,GAAG;YAAE,OAAO,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QAChD,OAAO,EAAE,CAAC;IACd,CAAC;;gHAlGQ,mBAAmB,kBAcR,UAAU;oHAdrB,mBAAmB;2FAAnB,mBAAmB;kBAD/B,UAAU;;0BAeM,MAAM;2BAAC,UAAU","sourcesContent":["import { Injectable, Inject } from '@angular/core';\nimport { LOC_LOCALE } from './tokens';\nimport { BaseLocalization } from './core/localization.base';\nimport { ItemLocalization } from './models';\n\n/**\n * Classe di localizzazione estendibile che permette di specificare le proprie localizzazioni e comunque rendere disponibili le localizzazioni globali\n */\n@Injectable()\nexport class LocalizationService {\n\n    /**\n     * Cache di tutte le localizzazioni disonibili all'interno di questa classe\n     */\n    TranslationCache: { [id: string]: ItemLocalization } = {};\n\n    /**\n     * Costruttore\n     * \n     * @param {string} baseLoc Locale da utilizzare nel momento che questo servizio richiede le traduzioni\n     * @param {baseLocalization} baseLocalization Classe base di localizzazione già fornita a livello di root dalla libreria stessa. \n     * È sufficiente iniettarla nell'eventuale costruttore che estende questa classe e passarla as-is\n     */\n    constructor(@Inject(LOC_LOCALE) private baseLoc: string, private baseLocalization?: BaseLocalization) { }\n\n    /**\n     * Imposta la localizzazione di un token all'interno della **TranslationCache**\n     * \n     * @param {string} direction Direzione della traduzione, rappresenta la lingua base in cui aspettarsi il testo e le varie lingue in cui viene tradotta.\n     * Ad esempio, \"en->it\" indica che il parametro **left** è valido per le localizzazioni in inglese, mentre nell'elemento 0 del parametro **right** \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\"\n     * @param {string} token Nome del token\n     * @param {string} left Valore del token per la lingua specificata nel lato immediatamente sinistro alla freccia del parametro **direction**\n     * @param {string} right Array con i valori facenti riferimento all'N-esima lingua del lato destro del parametro **direction**\n     */\n    protected setToken(direction: string, token: string, left: string, right: string[]) {\n        BaseLocalization.setToken(this.TranslationCache, direction, token, left, right);\n    }\n\n    /**\n     * Imposta la localizzazione di una frase all'interno della **TranslationCache**\n     * \n     * @param {string} direction Direzione della traduzione, rappresenta la lingua base in cui aspettarsi il testo e le varie lingue in cui viene tradotta.\n     * Ad esempio, \"en->it\" indica che il parametro **left** è valido per le localizzazioni in inglese, mentre nell'elemento 0 del parametro **right** \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\"\n     * @param {string} left Valore della frase per la lingua specificata nel lato immediatamente sinistro alla freccia del parametro **direction**\n     * @param {string} right Array con i valori facenti riferimento all'N-esima lingua del lato destro del parametro **direction**\n     */\n    protected set(direction: string, left: string, right: string[]) {\n        BaseLocalization.set(this.TranslationCache, direction, left, right);\n    }\n\n    /**\n     * Localizza un token\n     * \n     * @param {string} text Il token da localizzare\n     * \n     * @returns {string} Token localizzato\n     */\n    public token(text: string): string {\n        return this.loc(text, true);\n    }\n\n    /**\n     * Localizza una frase\n     * \n     * @param {string} text Frase da localizzare\n     * @param {boolean} allowtokens Indica se la frase **text** potrebbe essere un token o no\n     * \n     * @returns {string} Frase localizzata\n     */\n    public loc(text: string, allowtokens?: boolean): string {\n        if (!text || text == \"undefined\")\n            return \"\";\n\n        // Questo può succedere solo se qualcuno crea questa service a manazza. In quel caso prendo la classe di default e basta\n        if(this.baseLocalization == null)\n            this.baseLocalization = new BaseLocalization();\n            \n        // Prendo la localizzazione o dalla cache attuale o dalla cache del servizio base\n        var item = BaseLocalization.findByText(this.TranslationCache, text, allowtokens) || BaseLocalization.findByText(this.baseLocalization.BaseTranslations, text, allowtokens);\n        if (!item) {\n            console.error(\"Couldn't find localization for '\" + text + \"'\");\n            return \"\";\n        }\n\n        var loc = BaseLocalization.translationByCulture(item, this.baseLoc);\n        if (!loc) {\n            console.error(\"Couldn't find localization for '\" + text + \"', culture \" + this.baseLoc);\n            return \"\";\n        }\n\n        return loc.translation;\n    }\n\n    /**\n     * Localizzazione per Severity classiche (E per errore, W per warning e I per info)\n     * \n     * @param {string} text Severity da tradurre\n     * \n     * @returns {string} Severity tradotta\n     */\n    public locSeverity(text: string): string {\n        if (text == \"E\") return this.loc(\"Error\");\n        if (text == \"W\") return this.loc(\"Warning\");\n        if (text == \"I\") return this.loc(\"Information\");\n        return \"\";\n    }\n}"]}

package/esm2020/lib/pipes/loc_date.pipe.mjs

@@ -0,0 +1,43 @@
+// Angular
+import { Pipe, Optional } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "@esfaenza/extensions";
+/**
+ * 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
+ */
+export 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/YYY") {
+        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.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LocDatePipe, deps: [{ token: i1.DateService, optional: true }], target: i0.ɵɵFactoryTarget.Pipe });
+LocDatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LocDatePipe, name: "loc_date" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LocDatePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: "loc_date", pure: true }]
+        }], ctorParameters: function () { return [{ type: i1.DateService, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/pipes/localize.pipe.mjs

@@ -0,0 +1,39 @@
+// Angular
+import { Pipe } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "../localizations.service";
+/**
+ * Pipe di localizzazione per tradurre direttamente da template
+ */
+export class LocalizePipe {
+    /**
+     * Costruttore
+     *
+     * @param {LocalizationService} translationContainer Container delle traduzioni disponibili nel contesto in cui viene usata la pipe.
+     *
+     * Viene iniettata dal provider dichiarato nel singolo componente che utilizza la traduzione e, se non esiste, viene iniettato dal default
+     */
+    constructor(translationContainer) {
+        this.translationContainer = translationContainer;
+    }
+    /**
+     * Trasformazione della stringa in input ad una stringa tradotta
+     *
+     * @param {string} value Testo da tradurre
+     * @param {LocalizationService} locContainerOverride Override al contenitore della traduzione iniettato dal costruttore, qualora serva
+     *
+     * @returns {string} Frase tradotta
+     */
+    transform(value, locContainerOverride) {
+        if (value == null || value === "")
+            return "";
+        return (locContainerOverride || this.translationContainer).loc(value);
+    }
+}
+LocalizePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LocalizePipe, deps: [{ token: i1.LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
+LocalizePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LocalizePipe, name: "localize" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: LocalizePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: "localize", pure: true }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }]; } });
+//# sourceMappingURL=data:application/json;base64,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