@esfaenza/localizations 19.2.12 → 19.2.13

package/esm2020/lib/models/LocalizationModuleConfig.mjs

@@ -0,0 +1,6 @@
+/**
+ * Classe di configurazione per il modulo di localizzazione
+ */
+export class LocalizationModuleConfig {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9jYWxpemF0aW9uTW9kdWxlQ29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbG9jYWxpemF0aW9ucy9zcmMvbGliL21vZGVscy9Mb2NhbGl6YXRpb25Nb2R1bGVDb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUE7O0dBRUc7QUFDSCxNQUFNLE9BQU8sd0JBQXdCO0NBZ0JwQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFR5cGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5pbXBvcnQgeyBMb2NhbGVQZXJzaXN0b3IgfSBmcm9tIFwiLi4vbG9jYWxlLXBlcnNpc3Rvci9Mb2NhbGVQZXJzaXN0b3JcIjtcclxuaW1wb3J0IHsgTG9jYWxpemF0aW9uTWlzc2luZ1BvbGljeSB9IGZyb20gXCIuL0xvY2FsaXphdGlvbk1pc3NpbmdQb2xpY3lcIjtcclxuXHJcbi8qKlxyXG4gKiBDbGFzc2UgZGkgY29uZmlndXJhemlvbmUgcGVyIGlsIG1vZHVsbyBkaSBsb2NhbGl6emF6aW9uZVxyXG4gKi9cclxuZXhwb3J0IGNsYXNzIExvY2FsaXphdGlvbk1vZHVsZUNvbmZpZyB7XHJcblxyXG4gIC8qKiBMb2NhbGUgZGkgZGVmYXVsdCB1dGlsaXp6YXRvIHBlciByaWNoaWVkZXJlIGxlIHRyYWR1emlvbmkgKi9cclxuICBkZWZhdWx0TG9jYWxlPzogc3RyaW5nO1xyXG5cclxuICAvKipcclxuICAgKiBDbGFzc2UgY2hlIHNpIGRldmUgb2NjdXBhcmUgZGVsbG8gc3RvcmUgXCJEZWZpbml0aXZvXCIgZGVsbGUgaW5mbyBzdWwgbG9jYWxlIHV0aWxpenphdG8uIERpIGRlZmF1bHQgdmllbmUgcHJvcG9zdG8gdW5vIHN0b3JlIGxhdG8gbG9jYWxTdG9yYWdlIG1hIHNpIHB1w7IgZmFjaWxtZW50ZSBcclxuICAgKiBmb3JuaXJlIHVubyBzdG9yYWdlIGNoZSBwb3J0YSBsZSBpbmZvcm1hemlvbmkgbGF0byBEYXRhYmFzZSBpbiBtb2RvIGRhIGF2ZXJlIGxhIHN0ZXNzYSBsaW5ndWEgZmlubyBhIGNoZSBub24gdmllbmUgY2FtYmlhdGEgKEVzLiBQcmVmZXJlbmNlIHN0b3JhZ2UpXHJcbiAgICovXHJcbiAgbG9jYWxlUGVyc2lzdG9yPzogVHlwZTxMb2NhbGVQZXJzaXN0b3I+O1xyXG5cclxuICAvKiogUG9saWN5IGRpIGNvc2EgZmFyZSBpbiBjYXNvIGlsIHNpc3RlbWEgbm9uIHJpZXNjYSBhIHRyb3ZhcmUgdW5hIGRlbGxlIHRyYWR1emlvbmkgKi9cclxuICBsb2NhbGl6YXRpb25NaXNzaW5nUG9saWN5PzogTG9jYWxpemF0aW9uTWlzc2luZ1BvbGljeVxyXG5cclxuICAvKiogQXR0aXZhIGxhIG1vZGFsaXTDoCBkaSBkZWJ1ZyBwZXIgbCdlc3Bvc2l6aW9uZSBkaSBtZXNzYWdnaSBzaWduaWZpY2F0aXZpICovXHJcbiAgZGVidWdNb2RlPzogYm9vbGVhbjtcclxufSJdfQ==

package/esm2020/lib/models/SpecializedLocalization.mjs

@@ -0,0 +1,16 @@
+/**
+ * Classe che rappresenta la localizzazione di un test base per una certa lingua
+ */
+export class SpecializedLocalization {
+    /**
+     * Costruttore
+     *
+     * @param {string} culture Culture della traduzione
+     * @param {string} translation Traduzione nella lingua specificata dalla **culture**
+     */
+    constructor(culture, translation) {
+        this.culture = culture;
+        this.translation = translation;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3BlY2lhbGl6ZWRMb2NhbGl6YXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9sb2NhbGl6YXRpb25zL3NyYy9saWIvbW9kZWxzL1NwZWNpYWxpemVkTG9jYWxpemF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxPQUFPLHVCQUF1QjtJQUVsQzs7Ozs7T0FLRztJQUNILFlBQW1CLE9BQWUsRUFBUyxXQUFtQjtRQUEzQyxZQUFPLEdBQVAsT0FBTyxDQUFRO1FBQVMsZ0JBQVcsR0FBWCxXQUFXLENBQVE7SUFBSSxDQUFDO0NBQ3BFIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIENsYXNzZSBjaGUgcmFwcHJlc2VudGEgbGEgbG9jYWxpenphemlvbmUgZGkgdW4gdGVzdCBiYXNlIHBlciB1bmEgY2VydGEgbGluZ3VhXHJcbiAqL1xyXG5leHBvcnQgY2xhc3MgU3BlY2lhbGl6ZWRMb2NhbGl6YXRpb24ge1xyXG5cclxuICAvKipcclxuICAgKiBDb3N0cnV0dG9yZVxyXG4gICAqIFxyXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBjdWx0dXJlIEN1bHR1cmUgZGVsbGEgdHJhZHV6aW9uZVxyXG4gICAqIEBwYXJhbSB7c3RyaW5nfSB0cmFuc2xhdGlvbiBUcmFkdXppb25lIG5lbGxhIGxpbmd1YSBzcGVjaWZpY2F0YSBkYWxsYSAqKmN1bHR1cmUqKlxyXG4gICAqL1xyXG4gIGNvbnN0cnVjdG9yKHB1YmxpYyBjdWx0dXJlOiBzdHJpbmcsIHB1YmxpYyB0cmFuc2xhdGlvbjogc3RyaW5nKSB7IH1cclxufVxyXG4iXX0=

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

@@ -0,0 +1,42 @@
+// 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: "15.2.9", ngImport: i0, type: LocalizePipe, deps: [{ token: i1.LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
+LocalizePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: LocalizePipe, name: "localize" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LocalizePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "localize", pure: true,
+                    standalone: false
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocalizationService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/tokens.mjs

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@angular/core';
+/** Locale da utilizzare per le traduzioni */
+export const LOC_LOCALE = new InjectionToken('LOC_LOCALE');
+/** Policy da utilizzare per traduzioni mancanti */
+export const LOC_MISSING_POLICY = new InjectionToken('LOC_MISSING_POLICY');
+/** Modalità di Debug */
+export const LOC_DEBUG_MODE = new InjectionToken('LOC_DEBUG_MODE');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbG9jYWxpemF0aW9ucy9zcmMvbGliL3Rva2Vucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRy9DLDZDQUE2QztBQUM3QyxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQTJCLElBQUksY0FBYyxDQUFTLFlBQVksQ0FBQyxDQUFDO0FBRTNGLG1EQUFtRDtBQUNuRCxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBOEMsSUFBSSxjQUFjLENBQTRCLG9CQUFvQixDQUFDLENBQUM7QUFFakosd0JBQXdCO0FBQ3hCLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBNEIsSUFBSSxjQUFjLENBQVUsZ0JBQWdCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IExvY2FsaXphdGlvbk1pc3NpbmdQb2xpY3kgfSBmcm9tIFwiLi9tb2RlbHMvTG9jYWxpemF0aW9uTWlzc2luZ1BvbGljeVwiXHJcblxyXG4vKiogTG9jYWxlIGRhIHV0aWxpenphcmUgcGVyIGxlIHRyYWR1emlvbmkgKi9cclxuZXhwb3J0IGNvbnN0IExPQ19MT0NBTEU6IEluamVjdGlvblRva2VuPHN0cmluZz4gPSBuZXcgSW5qZWN0aW9uVG9rZW48c3RyaW5nPignTE9DX0xPQ0FMRScpO1xyXG5cclxuLyoqIFBvbGljeSBkYSB1dGlsaXp6YXJlIHBlciB0cmFkdXppb25pIG1hbmNhbnRpICovXHJcbmV4cG9ydCBjb25zdCBMT0NfTUlTU0lOR19QT0xJQ1k6IEluamVjdGlvblRva2VuPExvY2FsaXphdGlvbk1pc3NpbmdQb2xpY3k+ID0gbmV3IEluamVjdGlvblRva2VuPExvY2FsaXphdGlvbk1pc3NpbmdQb2xpY3k+KCdMT0NfTUlTU0lOR19QT0xJQ1knKTtcclxuXHJcbi8qKiBNb2RhbGl0w6AgZGkgRGVidWcgKi9cclxuZXhwb3J0IGNvbnN0IExPQ19ERUJVR19NT0RFOiBJbmplY3Rpb25Ub2tlbjxib29sZWFuPiA9IG5ldyBJbmplY3Rpb25Ub2tlbjxib29sZWFuPignTE9DX0RFQlVHX01PREUnKTsiXX0=

package/esm2020/public-api.mjs

@@ -0,0 +1,12 @@
+/*
+ * Public API Surface of localizations
+ */
+export * from './lib/core/localization.base';
+export * from './lib/localizations.module';
+export * from './lib/localizations.service';
+export * from './lib/pipes/localize.pipe';
+export * from './lib/tokens';
+export * from './lib/models/LocalizationModuleConfig';
+export * from './lib/models/BaseLocalizationTokens';
+export * from './lib/models/LocalizationMissingPolicy';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2xvY2FsaXphdGlvbnMvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLHdDQUF3QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcclxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGxvY2FsaXphdGlvbnNcclxuICovXHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb3JlL2xvY2FsaXphdGlvbi5iYXNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvbG9jYWxpemF0aW9ucy5tb2R1bGUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9sb2NhbGl6YXRpb25zLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9waXBlcy9sb2NhbGl6ZS5waXBlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvdG9rZW5zJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvbW9kZWxzL0xvY2FsaXphdGlvbk1vZHVsZUNvbmZpZyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL21vZGVscy9CYXNlTG9jYWxpemF0aW9uVG9rZW5zJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvbW9kZWxzL0xvY2FsaXphdGlvbk1pc3NpbmdQb2xpY3knOyJdfQ==

package/fesm2015/esfaenza-localizations.mjs

@@ -0,0 +1,543 @@
+import { __awaiter } from 'tslib';
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, Inject, Injector, Pipe, NgModule } from '@angular/core';
+import { take, first } from 'rxjs/operators';
+import { ReplaySubject, of } from 'rxjs';
+
+/**
+ * Contenitore delle localizzazioni collegate ad un testo "base", una per ogni linguaggio supportato
+ */
+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;
+    }
+}
+
+/**
+ * Classe che rappresenta un locale (Es. 'Italiano') con i propri alias (Es. 'it' oppure 'it-IT')
+ */
+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;
+    }
+}
+
+/** Classe che gestisce le definizioni dei locali disponibili */
+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")
+];
+
+/**
+ * Classe che rappresenta la localizzazione di un test base per una certa lingua
+ */
+class SpecializedLocalization {
+    /**
+     * Costruttore
+     *
+     * @param {string} culture Culture della traduzione
+     * @param {string} translation Traduzione nella lingua specificata dalla **culture**
+     */
+    constructor(culture, translation) {
+        this.culture = culture;
+        this.translation = translation;
+    }
+}
+
+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;
+    }
+}
+
+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 = {}));
+
+/** Locale da utilizzare per le traduzioni */
+const LOC_LOCALE = new InjectionToken('LOC_LOCALE');
+/** Policy da utilizzare per traduzioni mancanti */
+const LOC_MISSING_POLICY = new InjectionToken('LOC_MISSING_POLICY');
+/** Modalità di Debug */
+const LOC_DEBUG_MODE = new InjectionToken('LOC_DEBUG_MODE');
+
+/** Classe astratta che rappresenta lo stato di persistenza fra la libreria e uno storage */
+class LocalePersistor {
+    constructor() {
+        /** Chiave su cui salvare il locale */
+        this.LOCALE = "LOCALE";
+    }
+}
+
+/**
+ * Classe singleton che contiene le traduzioni di base (per evitare di ripeterle in oggi classe di traduzione) e le funzioni base per
+ * inserire e leggere traduzioni in/da una cache
+ */
+class BaseLocalization {
+    /**
+     * Costruttore. Da qui utilizzando il metodo statico **BaseLocalization.set** si va a popolare la cache delle traduzioni **BaseTranslations**
+     */
+    constructor(LocalePersistor, defaultLocale) {
+        this.LocalePersistor = LocalePersistor;
+        /**
+         * Cache di tutte le localizzazioni di base
+         */
+        this.LocCache = {};
+        /**
+         * Locale di riferimento per tutte le traduzioni
+         */
+        this.Locale = new ReplaySubject(1);
+        // Recupero il locale alla partenza del BaseLocalization in modo, spero di dare tempo all'applicazione di tirarlo su
+        this.LocalePersistor.recover().pipe(take(1)).subscribe((l) => __awaiter(this, void 0, void 0, function* () {
+            if (!l) {
+                l = defaultLocale;
+                this.LocalePersistor.persist(defaultLocale);
+            }
+            this.Locale.next(l);
+        }));
+        this.Persistor = new LocalizationPersistor(this.LocCache);
+        this.Persistor.set("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: 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: LocalePersistor }, { type: undefined, decorators: [{
+                        type: Inject,
+                        args: [LOC_LOCALE]
+                    }] }];
+    } });
+
+/**
+ * Enum che rappresenta le policy di comportamento qualore il sistema di localizzazione non trovi la localizzazione cercata,
+ * usare **ThrowException** solo se ci si sente infallibili o si vuole debuggare in maniera approfondita l'applicazione
+ */
+var LocalizationMissingPolicy;
+(function (LocalizationMissingPolicy) {
+    LocalizationMissingPolicy[LocalizationMissingPolicy["PrintEmpty"] = 0] = "PrintEmpty";
+    LocalizationMissingPolicy[LocalizationMissingPolicy["PrintSource"] = 1] = "PrintSource";
+    LocalizationMissingPolicy[LocalizationMissingPolicy["PrintSourceWithoutWarnings"] = 2] = "PrintSourceWithoutWarnings";
+    LocalizationMissingPolicy[LocalizationMissingPolicy["ThrowException"] = 3] = "ThrowException";
+})(LocalizationMissingPolicy || (LocalizationMissingPolicy = {}));
+
+/**
+ * Classe di localizzazione estendibile che permette di specificare le proprie localizzazioni e comunque rendere disponibili le localizzazioni globali
+ */
+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;
+    }
+    changeLocale(newLocale) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let locale = yield this.LocalePersistor.recover().toPromise();
+            if (newLocale == locale) {
+                console.info("Il locale richiesto è lo stesso del locale attuale. Ignoro l'operazione");
+                return;
+            }
+            else {
+                yield this.LocalePersistor.persist(newLocale).toPromise();
+                location.reload();
+            }
+        });
+    }
+}
+LocalizationService.ɵ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 }]; } });
+
+// Angular
+/**
+ * Pipe di localizzazione per tradurre direttamente da template
+ */
+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: "15.2.9", ngImport: i0, type: LocalizePipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
+LocalizePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: LocalizePipe, name: "localize" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LocalizePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "localize", pure: true,
+                    standalone: false
+                }]
+        }], ctorParameters: function () { return [{ type: LocalizationService }]; } });
+
+// Angular
+class LocalStorageLocalePersistor extends LocalePersistor {
+    /** @ignore Vedi classe base */
+    persist(locale) {
+        localStorage.setItem(this.LOCALE, locale);
+        return of(true).pipe(first());
+    }
+    /** @ignore Vedi classe base */
+    recover() {
+        var ret = localStorage.getItem(this.LOCALE);
+        return of(ret).pipe(first());
+    }
+}
+LocalStorageLocalePersistor.ɵ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
+        }] });
+
+// Angular
+class LocalizationModule {
+    static forRoot(config) {
+        return {
+            ngModule: LocalizationModule,
+            providers: [
+                LocalizationService,
+                BaseLocalization,
+                { provide: LOC_LOCALE, useValue: (config === null || config === void 0 ? void 0 : config.defaultLocale) || 'it-IT' },
+                { provide: LOC_MISSING_POLICY, useValue: (config === null || config === void 0 ? void 0 : config.localizationMissingPolicy) || LocalizationMissingPolicy.PrintEmpty },
+                { provide: LocalePersistor, useClass: (config === null || config === void 0 ? void 0 : config.localePersistor) || LocalStorageLocalePersistor },
+                { provide: LOC_DEBUG_MODE, useValue: (config === null || config === void 0 ? void 0 : 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]
+                }]
+        }] });
+
+/**
+ * Classe di configurazione per il modulo di localizzazione
+ */
+class LocalizationModuleConfig {
+}
+
+/*
+ * Public API Surface of localizations
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BaseLocalization, BaseLocalizationTokens, LOC_DEBUG_MODE, LOC_LOCALE, LOC_MISSING_POLICY, LocalizationMissingPolicy, LocalizationModule, LocalizationModuleConfig, LocalizationService, LocalizePipe };
+//# sourceMappingURL=esfaenza-localizations.mjs.map