turbogui-angular 15.2.0 → 15.3.0

package/esm2022/main/controller/locales.service.mjs

@@ -0,0 +1,492 @@
+/**
+ * TurboGUI is A library that helps with the most common and generic UI elements and functionalities
+ *
+ * Website : -> http://www.turbogui.org
+ * License : -> Licensed under the Apache License, Version 2.0. You may not use this file except in compliance with the License.
+ * License Url : -> http://www.apache.org/licenses/LICENSE-2.0
+ * CopyRight : -> Copyright 2018 Edertone Advanded Solutions. https://www.edertone.com
+ */
+import { Injectable } from '@angular/core';
+import { SingletoneStrictClass } from '../model/classes/SingletoneStrictClass';
+import * as i0 from "@angular/core";
+/**
+ * Manages application text translations and languages
+ */
+export class LocalesService extends SingletoneStrictClass {
+    /**
+     * Fully featured translation manager to be used with any application that requires text internationalization.
+     */
+    constructor() {
+        super(LocalesService);
+        /**
+         * if the class has been correctly initialized and translations have been correctly loaded
+         */
+        this._isInitialized = false;
+        /**
+         * @see getLocales()
+         */
+        this._locales = [];
+        /**
+         * @see getLanguages()
+         */
+        this._languages = [];
+        /**
+         * Stores all the loaded localization data by library name, bundle name, key and locales
+         */
+        this._loadedTranslations = {};
+        /**
+         * Stores a memory cache to improve performance when outputing translations
+         */
+        this._keyValuesCache = {};
+        /**
+         * @see setWildCardsFormat()
+         */
+        this._wildCardsFormat = '{N}';
+        /**
+         * @see setMissingKeyFormat()
+         */
+        this._missingKeyFormat = '$exception';
+        /**
+         * Stores a hash value that is used to improve the performance for translation t() methods.
+         * This is computed based on _wildCardsFormat plus _missingKeyFormat plus the current primary locale
+         * Methods that change these values will recalculate the hash string, so when calling translation methods, the
+         * performance will be as fast as possible.
+         */
+        this._cacheHashBaseString = '';
+    }
+    /**
+     * Wildcards are string fragments that are placed inside the translated texts. Their main purpose is to be replaced at
+     * runtime by custom values like for example a user name, a date, a numeric value, etc..
+     *
+     * This class helps with this process by including a parameter called 'toReplace' on all ->t methods which allows us
+     * to specify a string or list of strings that will replace the respective wildcards on the translated text. Each wildcard
+     * must follow the format specified here, and contain a numeric digit that will be used to find the replacement text at the
+     * 'toReplace' list. For example, if we define $N as the wildcard format, and we have a translation that contains $0, $1, $2,
+     * $0 will be replaced with the first element on toReplace, $1 with the second and so.
+     *
+     * We usually set this before initializing the class translation data
+     *
+     * Notice that N is mandayory on the wildcards format and the first index value is 0.
+     *
+     * @param value The wildcards format we want to set
+     *
+     * @returns The value that's been set
+     */
+    setWildCardsFormat(value) {
+        if (!value.includes('N')) {
+            throw new Error("N is mandatory to replace wildcards");
+        }
+        this._cacheHashBaseString = value + this._missingKeyFormat + ((this._locales.length > 0) ? this._locales[0] : '');
+        this._wildCardsFormat = value;
+        return value;
+    }
+    /**
+     * Defines the behaviour for get(), getStartCase(), etc... methods when a key is not found on
+     * a bundle or the bundle does not exist
+     *
+     * If missingKeyFormat is an empty string, all missing keys will return an empty value (not recommended)
+     *
+     * If missingKeyFormat contains a string, that string will be always returned for missing keys
+     *
+     * If missingKeyFormat contains a string with one of the following predefined wildcards:<br>
+     *    - $key will be replaced with key name. Example: get("NAME") will output [NAME] if key is not found and missingKeyFormat = '[$key]'<br>
+     *    - $exception (default value) will throw an exception with the problem cause description.
+     *
+     * @param value The missing key format we want to set
+     *
+     * @returns The value that's been set
+     */
+    setMissingKeyFormat(value) {
+        this._cacheHashBaseString = this._wildCardsFormat + value + ((this._locales.length > 0) ? this._locales[0] : '');
+        this._missingKeyFormat = value;
+        return value;
+    }
+    /**
+     * @see setMissingKeyFormat()
+     */
+    getMissingKeyFormat() {
+        return this._missingKeyFormat;
+    }
+    /**
+     * Initializes the translation system by loading and parsing bundle files from the specified translations path.
+     *
+     * @param translationsPath - Url where the translations Json structure of libraries/bundles/locales/keys is available.
+     * @param locales An array of locale codes (e.g., ['en_US', 'es_ES', 'fr_FR']) to load. These will be added to the translation
+     *        path using the following format: translationsPath/en_US-es_ES-fr_FR. The order of this array will determine the
+     *        translation priority
+     * @param parameters Any extra parameters to be attached to the translationsPath after the locales like /param1/param2/ etc
+     *
+     * @return A promise that will resolve if the translations get correctly loaded, or reject with an error if load fails
+     */
+    initialize(translationsPath, locales, parameters) {
+        this._isInitialized = false;
+        this._loadedTranslations = {};
+        // Validate received locales are correct
+        for (const locale of locales) {
+            this._validateLocaleString(locale);
+        }
+        let translationsFullPath = translationsPath + '/' + locales.join('-') + '/' + parameters.join('/');
+        return new Promise((resolve, reject) => {
+            fetch(translationsFullPath).then(response => {
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                return response.json();
+            }).then(data => {
+                this._loadedTranslations = data;
+                this._isInitialized = true;
+                this._locales = locales;
+                this._languages = locales.map((l) => l.substring(0, 2));
+                this._cacheHashBaseString = this._wildCardsFormat + this._missingKeyFormat + this._locales[0];
+                resolve(undefined);
+            }).catch(error => {
+                reject(new Error(`ERROR LOADING LOCALES FROM: ${translationsFullPath}\n` + error));
+            });
+        });
+    }
+    /**
+     * Check if the class has been correctly initialized and translations have been correctly loaded
+     */
+    isInitialized() {
+        return this._isInitialized;
+    }
+    /**
+     * Aux method to verify that this class is correctly initialized with translation data
+     */
+    _validateInitialized() {
+        if (!this._isInitialized) {
+            throw new Error('LocalesManager not initialized');
+        }
+    }
+    /**
+     * Checks if the specified locale is currently loaded for the currently defined bundles and paths.
+     *
+     * @param locale A locale to check. For example 'en_US'
+     *
+     * @return True if the locale is currently loaded on the class, false if not.
+     */
+    isLocaleLoaded(locale) {
+        this._validateLocaleString(locale);
+        return this._locales.includes(locale);
+    }
+    /**
+     * Aux method to validate that a locale string is correctly formatted
+     *
+     * @param string $locale A locale string
+     */
+    _validateLocaleString(locale) {
+        if (!/^[a-z]{2}_[A-Z]{2}$/.test(locale)) {
+            throw new Error('locale must be a valid xx_XX value');
+        }
+    }
+    /**
+     * Checks if the specified 2 digit language is currently loaded for the currently defined bundles and paths.
+     *
+     * @param language A language to check. For example 'en'
+     *
+     * @return True if the language is currently loaded on the class, false if not.
+     */
+    isLanguageLoaded(language) {
+        this._validateLanguageString(language);
+        return this._languages.includes(language);
+    }
+    /**
+     * Aux method to validate that a language string is correctly formatted
+     *
+     * @param language A 2 digit language string
+     */
+    _validateLanguageString(language) {
+        if (!/^[a-z]{2}$/.test(language)) {
+            throw new Error('language must be a valid 2 digit value');
+        }
+    }
+    /**
+     * Get the translation to the current primary locale for the given key, library and bundle
+     *
+     * @param string key The key we want to read from the specified resource bundle
+     * @param string bundlePath A string with the format 'library_name/bundle_name' that is used to locate the bundle were the key to translate is found
+     * @param array replaceWildcards A list of values that will replace wildcards that may be found on the translated text. Each wildcard
+     *        will be replaced with the element whose index on toReplace matches it. Check the documentation for this.wildCardsFormat
+     *        property to know more about how to setup wildcards.
+     *
+     * @see setWildCardsFormat()
+     *
+     * @return The translated text
+     */
+    t(key, bundlePath, replaceWildcards = []) {
+        this._validateInitialized();
+        // Create a cache key to improve performance when requesting the same key translation several times
+        const cacheKey = `${this._cacheHashBaseString}${key}${bundlePath}${replaceWildcards.join('')}`;
+        if (!this._keyValuesCache[cacheKey]) {
+            this._forceNonEmptyString(key, '', 'key must be non empty string');
+            this._forceNonEmptyString(bundlePath, '', 'bundlePath must be non empty string');
+            const [library, bundle] = bundlePath.split('/');
+            this._forceNonEmptyString(library, '', 'no library specified on bundlePath');
+            this._forceNonEmptyString(bundle, '', 'no bundle specified on bundlePath');
+            const replacementsCount = replaceWildcards.length;
+            // Loop all the locales to find the first one with a value for the specified key
+            for (const locale of this._locales) {
+                if (this._loadedTranslations[library]?.[bundle]?.[locale]?.[key]) {
+                    let result = this._loadedTranslations[library][bundle][locale][key];
+                    // Replace all wildcards on the text with the specified replacements if any
+                    for (let i = 0; i < replacementsCount; i++) {
+                        result = this._replace(result, this._replace(this._wildCardsFormat, 'N', i.toString()), replaceWildcards[i]);
+                    }
+                    this._keyValuesCache[cacheKey] = result;
+                    return result;
+                }
+            }
+            // Check if an exception needs to be thrown if the specified key is not found on this bundle
+            if (this._missingKeyFormat.includes('$exception')) {
+                throw new Error(`key <${key}> not found on ${bundlePath}`);
+            }
+            this._keyValuesCache[cacheKey] = this._replace(this._missingKeyFormat, '$key', key);
+        }
+        return this._keyValuesCache[cacheKey];
+    }
+    /**
+     * Get the translation for the given key and bundle as a string with all words first character capitalized
+     * and all the rest of the word with lower case
+     *
+     * @see t()
+     *
+     * @returns The localized and case formatted text
+     */
+    tStartCase(key, bundlePath, replaceWildcards = []) {
+        return this.t(key, bundlePath, replaceWildcards).split(' ')
+            .map((word) => word ? word[0].toUpperCase() + word.slice(1).toLowerCase() : '').join(' ');
+    }
+    /**
+     * Get the translation for the given key and bundle as an all upper case string
+     *
+     * @see t()
+     *
+     * @returns The localized and case formatted text
+     */
+    tAllUpperCase(key, bundlePath, replaceWildcards = []) {
+        return this.t(key, bundlePath, replaceWildcards).toUpperCase();
+    }
+    /**
+     * Get the translation for the given key and bundle as an all lower case string
+     *
+     * @see t()
+     *
+     * @returns The localized and case formatted text
+     */
+    tAllLowerCase(key, bundlePath, replaceWildcards = []) {
+        return this.t(key, bundlePath, replaceWildcards).toLowerCase();
+    }
+    /**
+     * Get the translation for the given key and bundle as a string with the first character as Upper case
+     * and all the rest as lower case
+     *
+     * @see t()
+     *
+     * @returns The localized and case formatted text
+     */
+    tFirstUpperRestLower(key, bundlePath, replaceWildcards = []) {
+        const string = this.t(key, bundlePath, replaceWildcards);
+        return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
+    }
+    /**
+     * A list of strings containing the locales that are used by this class to translate the given keys, sorted by preference.
+     * Each string is formatted as a standard locale code with language and country joined by an underscore, like: en_US, fr_FR
+     *
+     * When a key and bundle are requested for translation, the class will check on the first language of this
+     * list for a translated text. If missing, the next one will be used, and so. This list is constructed after initialize
+     * methods is called.
+     *
+     * @example: After loading the following list of locales ['en_US', 'es_ES', 'fr_FR'] if we call LocalesManager.t('HELLO', 'lib1/greetings')
+     * the localization manager will try to locate the en_US value for the HELLO tag on the greetings bundle for the library lib1.
+     * If the tag is not found for the specified locale and bundle, the same search will be performed for the es_ES locale, and so, till a
+     * value is found or no more locales are defined.
+     */
+    getLocales() {
+        return this._locales;
+    }
+    /**
+     * A list of strings containing the languages that are used by this class to translate the given keys, sorted by preference.
+     * Each string is formatted as a 2 digit language code, like: en, fr
+     *
+     * This list is the same as the locales() one, but containing only the language part of each locale (the first two digits)
+     *
+     * @see getLocales()
+     */
+    getLanguages() {
+        return this._languages;
+    }
+    /**
+     * Get the first locale from the list of loaded locales, which is the currently used to search for translated texts.
+     *
+     * @returns The locale that is defined as the primary one. For example: en_US, es_ES, ..
+     */
+    getPrimaryLocale() {
+        this._validateInitialized();
+        return this._locales[0];
+    }
+    /**
+     * Get the first language from the list of loaded locales, which is the currently used to search for translated texts.
+     *
+     * @returns The 2 digit language code that is defined as the primary one. For example: en, es, ..
+     */
+    getPrimaryLanguage() {
+        this._validateInitialized();
+        return this._languages[0];
+    }
+    /**
+     * Define the locale that will be placed at the front of the currently loaded locales list (moving all the others one position to the right).
+     *
+     * This will be the first locale to use when trying to get a translation.
+     *
+     * @param locale A currently loaded locale that will be moved to the first position of the loaded locales list. If the specified locale
+     *        is not currently loaded, an exception will happen.
+     *
+     * @returns void
+     */
+    setPrimaryLocale(locale) {
+        this._validateInitialized();
+        if (!this.isLocaleLoaded(locale)) {
+            throw new Error(locale + ' not loaded');
+        }
+        let result = [locale];
+        for (let l of this._locales) {
+            if (l !== locale) {
+                result.push(l);
+            }
+        }
+        this._locales = result;
+        this._languages = this._locales.map((l) => l.substring(0, 2));
+        this._cacheHashBaseString = this._wildCardsFormat + this._missingKeyFormat + this._locales[0];
+    }
+    /**
+     * Moves the specified locales to the beginning of the locales list. This also alters the translation priority by setting the first
+     * provided locale as the most prioritary, the second as the next one and so.
+     *
+     * This method basically works exactly the same way as setPrimaryLocale but letting us add many locales at once.
+     *
+     * @see setPrimaryLocale()
+     *
+     * @param locales A list of locales to be moved to the beginning of the translation priority. First locales item will be the prefered
+     *        locale for translation, second will be the next one in case some key is not translated for the first one and so. If any of the
+     *        specified locales is not currently loaded, an exception will happen.
+     *
+     * @returns void
+     */
+    setPrimaryLocales(locales) {
+        if (!Array.isArray(locales) ||
+            (new Set(locales).size !== locales.length) ||
+            locales.length === 0) {
+            throw new Error('locales must be non empty string array with no duplicate elements');
+        }
+        for (let i = locales.length - 1; i >= 0; i--) {
+            this.setPrimaryLocale(locales[i]);
+        }
+    }
+    /**
+     * Define the 2 digit language that will be placed at the front of the currently loaded locales list (moving all the others one position to the right).
+     *
+     * This will be the first language to use when trying to get a translation.
+     *
+     * @param language A 2 digit language code that matches with any of the currently loaded locales, which will
+     *        be moved to the first position of the loaded locales list. If the specified language does not match with
+     *        a locale that is currently loaded, an exception will happen.
+     *
+     * @returns void
+     */
+    setPrimaryLanguage(language) {
+        for (let locale of this._locales) {
+            if (locale.substring(0, 2) === language) {
+                this.setPrimaryLocale(locale);
+                return;
+            }
+        }
+        throw new Error(language + ' not loaded');
+    }
+    /**
+     * Moves the locales that match the specified languages to the beginning of the locales list.
+     * Works the same as setPrimaryLocales() but with a list of the 2 digit language codes that match the respective locales.
+     *
+     * @see setPrimaryLocale()
+     * @see setPrimaryLanguage()
+     *
+     * @param languages A list of 2 digit language codes to be moved to the beginning of the translation priority. If any of the
+     *        specified languages does not match with a locale that is currently loaded, an exception will happen.
+     *
+     * @returns void
+     */
+    setPrimaryLanguages(languages) {
+        if (!Array.isArray(languages) ||
+            (new Set(languages).size !== languages.length) ||
+            languages.length === 0) {
+            throw new Error('languages must be non empty string array with no duplicate elements');
+        }
+        for (let i = languages.length - 1; i >= 0; i--) {
+            this.setPrimaryLanguage(languages[i]);
+        }
+    }
+    /**
+     * Change the loaded locales translation preference order. The same locales that are currently loaded must be passed
+     * but with a different order to change the translation priority.
+     *
+     * @param locales A list with the new locales translation priority
+     *
+     * @returns void
+     */
+    setLocalesOrder(locales) {
+        if (locales.length !== this._locales.length) {
+            throw new Error('locales must contain all the currently loaded locales');
+        }
+        this._validateInitialized();
+        for (let locale of locales) {
+            if (!this.isLocaleLoaded(locale)) {
+                throw new Error(locale + ' not loaded');
+            }
+        }
+        this._locales = locales;
+        this._languages = this._locales.map((l) => l.substring(0, 2));
+        this._cacheHashBaseString = this._wildCardsFormat + this._missingKeyFormat + this._locales[0];
+    }
+    /**
+     * This is an aux method to implement the TurboCommons StringUtils replace method.
+     * It is exactly the same as the one on the library, but we implement it here to avoid having a dependency with TurboCommons
+     */
+    _replace(string, search, replacement) {
+        const escapedSearch = search.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return string.replace(new RegExp(escapedSearch, 'g'), replacement);
+    }
+    /**
+     * This is an aux method to implement the TurboCommons StringUtils isEmpty method.
+     * It is exactly the same as the one on the library, but we implement it here to avoid having a dependency with TurboCommons
+     */
+    _isEmpty(string) {
+        let isString = (typeof string === 'string' || string instanceof String);
+        // Throw exception if non string value was received
+        if (!isString) {
+            // Empty or null value is considered empty
+            if (string == null || string == '') {
+                return true;
+            }
+            throw new Error("value is not a string");
+        }
+        return string.replace(/[ \n\r\t]/g, '') === '';
+    }
+    /**
+     * This is an aux method to implement the TurboCommons StringUtils forceNonEmptyString method.
+     * It is exactly the same as the one on the library, but we implement it here to avoid having a dependency with TurboCommons
+     */
+    _forceNonEmptyString(value, valueName = '', errorMessage = 'must be a non empty string') {
+        let isString = (typeof value === 'string' || value instanceof String);
+        if (!isString || this._isEmpty(value)) {
+            throw new Error(valueName + ' ' + errorMessage);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: LocalesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: LocalesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: LocalesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"locales.service.js","sourceRoot":"","sources":["../../../../../projects/turbogui-angular/src/main/controller/locales.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * TurboGUI is A library that helps with the most common and generic UI elements and functionalities\r\n *\r\n * Website : -> http://www.turbogui.org\r\n * License : -> Licensed under the Apache License, Version 2.0. You may not use this file except in compliance with the License.\r\n * License Url : -> http://www.apache.org/licenses/LICENSE-2.0\r\n * CopyRight : -> Copyright 2018 Edertone Advanded Solutions. https://www.edertone.com\r\n */\r\n\r\nimport { Injectable } from '@angular/core';\r\nimport { SingletoneStrictClass } from '../model/classes/SingletoneStrictClass';\r\n\r\n\r\n/**\r\n * Manages application text translations and languages\r\n */\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class LocalesService extends SingletoneStrictClass {\r\n\r\n\r\n    /**\r\n     * if the class has been correctly initialized and translations have been correctly loaded\r\n     */\r\n    private _isInitialized = false;\r\n        \r\n\r\n    /**\r\n     * @see getLocales()\r\n     */\r\n    private _locales:string[] = [];\r\n    \r\n    \r\n    /**\r\n     * @see getLanguages()\r\n     */\r\n    private _languages:string[] = [];\r\n        \r\n    \r\n    /**\r\n     * Stores all the loaded localization data by library name, bundle name, key and locales\r\n     */\r\n    private _loadedTranslations:any = {};\r\n    \r\n    \r\n    /**\r\n     * Stores a memory cache to improve performance when outputing translations\r\n     */\r\n    private _keyValuesCache:any = {};\r\n\r\n\r\n    /**\r\n     * @see setWildCardsFormat()\r\n     */\r\n    private _wildCardsFormat = '{N}';\r\n\r\n\r\n    /**\r\n     * @see setMissingKeyFormat()\r\n     */\r\n    private _missingKeyFormat = '$exception';\r\n\r\n\r\n    /**\r\n     * Stores a hash value that is used to improve the performance for translation t() methods.\r\n     * This is computed based on _wildCardsFormat plus _missingKeyFormat plus the current primary locale\r\n     * Methods that change these values will recalculate the hash string, so when calling translation methods, the\r\n     * performance will be as fast as possible.\r\n     */\r\n    private _cacheHashBaseString = '';\r\n    \r\n    \r\n    /**\r\n     * Fully featured translation manager to be used with any application that requires text internationalization.\r\n     */\r\n    constructor() {\r\n\r\n        super(LocalesService);\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Wildcards are string fragments that are placed inside the translated texts. Their main purpose is to be replaced at\r\n     * runtime by custom values like for example a user name, a date, a numeric value, etc..\r\n     *\r\n     * This class helps with this process by including a parameter called 'toReplace' on all ->t methods which allows us\r\n     * to specify a string or list of strings that will replace the respective wildcards on the translated text. Each wildcard\r\n     * must follow the format specified here, and contain a numeric digit that will be used to find the replacement text at the\r\n     * 'toReplace' list. For example, if we define $N as the wildcard format, and we have a translation that contains $0, $1, $2,\r\n     * $0 will be replaced with the first element on toReplace, $1 with the second and so.\r\n     *\r\n     * We usually set this before initializing the class translation data\r\n     *\r\n     * Notice that N is mandayory on the wildcards format and the first index value is 0.\r\n     *\r\n     * @param value The wildcards format we want to set\r\n     * \r\n     * @returns The value that's been set\r\n     */\r\n    setWildCardsFormat(value:string) {\r\n\r\n        if(!value.includes('N')){\r\n        \r\n            throw new Error(\"N is mandatory to replace wildcards\");\r\n        }\r\n\r\n        this._cacheHashBaseString = value + this._missingKeyFormat + ((this._locales.length > 0) ? this._locales[0] : '');\r\n\r\n        this._wildCardsFormat = value;\r\n        \r\n        return value;\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Defines the behaviour for get(), getStartCase(), etc... methods when a key is not found on\r\n     * a bundle or the bundle does not exist\r\n     *\r\n     * If missingKeyFormat is an empty string, all missing keys will return an empty value (not recommended)\r\n     *\r\n     * If missingKeyFormat contains a string, that string will be always returned for missing keys\r\n     *\r\n     * If missingKeyFormat contains a string with one of the following predefined wildcards:<br>\r\n     *    - $key will be replaced with key name. Example: get(\"NAME\") will output [NAME] if key is not found and missingKeyFormat = '[$key]'<br>\r\n     *    - $exception (default value) will throw an exception with the problem cause description.\r\n     *\r\n     * @param value The missing key format we want to set\r\n     * \r\n     * @returns The value that's been set\r\n     */\r\n    setMissingKeyFormat(value:string) {\r\n\r\n        this._cacheHashBaseString = this._wildCardsFormat + value + ((this._locales.length > 0) ? this._locales[0] : '');\r\n\r\n        this._missingKeyFormat = value;\r\n        \r\n        return value;\r\n    }\r\n    \r\n    \r\n    /**\r\n     * @see setMissingKeyFormat()\r\n     */\r\n    getMissingKeyFormat() {\r\n\r\n        return this._missingKeyFormat;\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Initializes the translation system by loading and parsing bundle files from the specified translations path.\r\n     * \r\n     * @param translationsPath - Url where the translations Json structure of libraries/bundles/locales/keys is available.\r\n     * @param locales An array of locale codes (e.g., ['en_US', 'es_ES', 'fr_FR']) to load. These will be added to the translation\r\n     *        path using the following format: translationsPath/en_US-es_ES-fr_FR. The order of this array will determine the\r\n     *        translation priority\r\n     * @param parameters Any extra parameters to be attached to the translationsPath after the locales like /param1/param2/ etc\r\n     * \r\n     * @return A promise that will resolve if the translations get correctly loaded, or reject with an error if load fails \r\n     */\r\n    initialize(translationsPath:string, locales:string[], parameters:string[]){\r\n    \r\n        this._isInitialized = false;\r\n        this._loadedTranslations = {};\r\n        \r\n        // Validate received locales are correct\r\n        for(const locale of locales) {\r\n\r\n            this._validateLocaleString(locale);\r\n        }\r\n        \r\n        let translationsFullPath = translationsPath + '/' + locales.join('-') + '/' + parameters.join('/');\r\n        \r\n        return new Promise((resolve, reject) => {\r\n        \r\n            fetch(translationsFullPath).then(response => {\r\n                \r\n                if (!response.ok) {\r\n                    \r\n                  throw new Error(`HTTP error! status: ${response.status}`);\r\n                }\r\n                \r\n                return response.json();\r\n          \r\n            }).then(data => {\r\n                \r\n                this._loadedTranslations = data;\r\n                this._isInitialized = true;\r\n                this._locales = locales;\r\n                this._languages = locales.map((l: string) => l.substring(0, 2));\r\n                this._cacheHashBaseString = this._wildCardsFormat + this._missingKeyFormat + this._locales[0];\r\n                \r\n                resolve(undefined);\r\n          \r\n            }).catch(error => {\r\n            \r\n                reject(new Error(`ERROR LOADING LOCALES FROM: ${translationsFullPath}\\n` + error));\r\n            });\r\n        });\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Check if the class has been correctly initialized and translations have been correctly loaded\r\n     */\r\n    isInitialized(){\r\n\r\n        return this._isInitialized;\r\n    }\r\n\r\n\r\n    /**\r\n     * Aux method to verify that this class is correctly initialized with translation data\r\n     */\r\n    private _validateInitialized(){\r\n\r\n        if(!this._isInitialized){\r\n\r\n            throw new Error('LocalesManager not initialized');\r\n        }\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Checks if the specified locale is currently loaded for the currently defined bundles and paths.\r\n     *\r\n     * @param locale A locale to check. For example 'en_US'\r\n     *\r\n     * @return True if the locale is currently loaded on the class, false if not.\r\n     */\r\n    isLocaleLoaded(locale:string){\r\n\r\n        this._validateLocaleString(locale);\r\n\r\n        return this._locales.includes(locale);\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Aux method to validate that a locale string is correctly formatted\r\n     *\r\n     * @param string $locale A locale string\r\n     */\r\n    private _validateLocaleString(locale:string){\r\n        \r\n        if(!/^[a-z]{2}_[A-Z]{2}$/.test(locale)) {\r\n\r\n            throw new Error('locale must be a valid xx_XX value');\r\n        }\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Checks if the specified 2 digit language is currently loaded for the currently defined bundles and paths.\r\n     *\r\n     * @param language A language to check. For example 'en'\r\n     *\r\n     * @return True if the language is currently loaded on the class, false if not.\r\n     */\r\n    isLanguageLoaded(language:string){\r\n\r\n        this._validateLanguageString(language);\r\n\r\n        return this._languages.includes(language);\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Aux method to validate that a language string is correctly formatted\r\n     *\r\n     * @param language A 2 digit language string\r\n     */\r\n    _validateLanguageString(language:string){\r\n\r\n        if (!/^[a-z]{2}$/.test(language)) {\r\n\r\n            throw new Error('language must be a valid 2 digit value');\r\n        }\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Get the translation to the current primary locale for the given key, library and bundle\r\n     *\r\n     * @param string key The key we want to read from the specified resource bundle\r\n     * @param string bundlePath A string with the format 'library_name/bundle_name' that is used to locate the bundle were the key to translate is found\r\n     * @param array replaceWildcards A list of values that will replace wildcards that may be found on the translated text. Each wildcard\r\n     *        will be replaced with the element whose index on toReplace matches it. Check the documentation for this.wildCardsFormat\r\n     *        property to know more about how to setup wildcards.\r\n     *\r\n     * @see setWildCardsFormat()\r\n     *\r\n     * @return The translated text\r\n     */\r\n    t(key:string, bundlePath:string, replaceWildcards:string[] = []) {\r\n\r\n        this._validateInitialized();\r\n\r\n        // Create a cache key to improve performance when requesting the same key translation several times\r\n        const cacheKey = `${this._cacheHashBaseString}${key}${bundlePath}${replaceWildcards.join('')}`;\r\n\r\n        if (!this._keyValuesCache[cacheKey]) {\r\n\r\n            this._forceNonEmptyString(key, '', 'key must be non empty string');\r\n            this._forceNonEmptyString(bundlePath, '', 'bundlePath must be non empty string');\r\n            \r\n            const [library, bundle] = bundlePath.split('/');\r\n\r\n            this._forceNonEmptyString(library, '', 'no library specified on bundlePath');\r\n            this._forceNonEmptyString(bundle, '', 'no bundle specified on bundlePath');\r\n            \r\n            const replacementsCount = replaceWildcards.length;\r\n\r\n            // Loop all the locales to find the first one with a value for the specified key\r\n            for (const locale of this._locales) {\r\n\r\n                if (this._loadedTranslations[library]?.[bundle]?.[locale]?.[key]) {\r\n\r\n                    let result = this._loadedTranslations[library][bundle][locale][key];\r\n\r\n                    // Replace all wildcards on the text with the specified replacements if any\r\n                    for (let i = 0; i < replacementsCount; i++) {\r\n\r\n                        result = this._replace(result, this._replace(this._wildCardsFormat, 'N', i.toString()), replaceWildcards[i]);\r\n                    }\r\n\r\n                    this._keyValuesCache[cacheKey] = result;\r\n                    \r\n                    return result;\r\n                }\r\n            }\r\n\r\n            // Check if an exception needs to be thrown if the specified key is not found on this bundle\r\n            if (this._missingKeyFormat.includes('$exception')) {\r\n                \r\n                throw new Error(`key <${key}> not found on ${bundlePath}`);\r\n            }\r\n\r\n            this._keyValuesCache[cacheKey] = this._replace(this._missingKeyFormat, '$key', key);\r\n        }\r\n\r\n        return this._keyValuesCache[cacheKey];\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Get the translation for the given key and bundle as a string with all words first character capitalized\r\n     * and all the rest of the word with lower case\r\n     *\r\n     * @see t()\r\n     *\r\n     * @returns The localized and case formatted text\r\n     */\r\n    tStartCase(key:string, bundlePath:string, replaceWildcards:string[] = []) {\r\n\r\n        return this.t(key, bundlePath, replaceWildcards).split(' ')\r\n                .map((word:any) => word ? word[0].toUpperCase() + word.slice(1).toLowerCase() : '').join(' ');\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Get the translation for the given key and bundle as an all upper case string\r\n     *\r\n     * @see t()\r\n     *\r\n     * @returns The localized and case formatted text\r\n     */\r\n    tAllUpperCase(key:string, bundlePath:string, replaceWildcards:string[] = []) {\r\n\r\n        return this.t(key, bundlePath, replaceWildcards).toUpperCase();\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Get the translation for the given key and bundle as an all lower case string\r\n     *\r\n     * @see t()\r\n     *\r\n     * @returns The localized and case formatted text\r\n     */\r\n    tAllLowerCase(key:string, bundlePath:string, replaceWildcards:string[] = []) {\r\n\r\n        return this.t(key, bundlePath, replaceWildcards).toLowerCase();\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Get the translation for the given key and bundle as a string with the first character as Upper case\r\n     * and all the rest as lower case\r\n     *\r\n     * @see t()\r\n     *\r\n     * @returns The localized and case formatted text\r\n     */\r\n    tFirstUpperRestLower(key:string, bundlePath:string, replaceWildcards:string[] = []){\r\n\r\n        const string = this.t(key, bundlePath, replaceWildcards);\r\n        \r\n        return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();\r\n    }\r\n    \r\n    \r\n    /**\r\n     * A list of strings containing the locales that are used by this class to translate the given keys, sorted by preference.\r\n     * Each string is formatted as a standard locale code with language and country joined by an underscore, like: en_US, fr_FR\r\n     *\r\n     * When a key and bundle are requested for translation, the class will check on the first language of this\r\n     * list for a translated text. If missing, the next one will be used, and so. This list is constructed after initialize\r\n     * methods is called.\r\n     *\r\n     * @example: After loading the following list of locales ['en_US', 'es_ES', 'fr_FR'] if we call LocalesManager.t('HELLO', 'lib1/greetings')\r\n     * the localization manager will try to locate the en_US value for the HELLO tag on the greetings bundle for the library lib1.\r\n     * If the tag is not found for the specified locale and bundle, the same search will be performed for the es_ES locale, and so, till a\r\n     * value is found or no more locales are defined.\r\n     */\r\n    getLocales(){\r\n\r\n        return this._locales;\r\n    }\r\n    \r\n    \r\n    /**\r\n     * A list of strings containing the languages that are used by this class to translate the given keys, sorted by preference.\r\n     * Each string is formatted as a 2 digit language code, like: en, fr\r\n     *\r\n     * This list is the same as the locales() one, but containing only the language part of each locale (the first two digits)\r\n     *\r\n     * @see getLocales()\r\n     */\r\n    getLanguages(){\r\n\r\n        return this._languages;\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Get the first locale from the list of loaded locales, which is the currently used to search for translated texts.\r\n     *\r\n     * @returns The locale that is defined as the primary one. For example: en_US, es_ES, ..\r\n     */\r\n    getPrimaryLocale(){\r\n\r\n        this._validateInitialized();\r\n\r\n        return this._locales[0];\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Get the first language from the list of loaded locales, which is the currently used to search for translated texts.\r\n     *\r\n     * @returns The 2 digit language code that is defined as the primary one. For example: en, es, ..\r\n     */\r\n    getPrimaryLanguage(){\r\n\r\n        this._validateInitialized();\r\n\r\n        return this._languages[0];\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Define the locale that will be placed at the front of the currently loaded locales list (moving all the others one position to the right).\r\n     *\r\n     * This will be the first locale to use when trying to get a translation.\r\n     *\r\n     * @param locale A currently loaded locale that will be moved to the first position of the loaded locales list. If the specified locale\r\n     *        is not currently loaded, an exception will happen.\r\n     *\r\n     * @returns void\r\n     */\r\n    setPrimaryLocale(locale:string){\r\n\r\n        this._validateInitialized();\r\n\r\n        if(!this.isLocaleLoaded(locale)){\r\n\r\n            throw new Error(locale + ' not loaded');\r\n        }\r\n\r\n        let result = [locale];\r\n\r\n        for (let l of this._locales){\r\n        \r\n            if(l !== locale){\r\n\r\n                result.push(l);\r\n            }\r\n        }\r\n\r\n        this._locales = result;\r\n        this._languages = this._locales.map((l: string) => l.substring(0, 2));\r\n        this._cacheHashBaseString = this._wildCardsFormat + this._missingKeyFormat + this._locales[0];\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Moves the specified locales to the beginning of the locales list. This also alters the translation priority by setting the first\r\n     * provided locale as the most prioritary, the second as the next one and so.\r\n     *\r\n     * This method basically works exactly the same way as setPrimaryLocale but letting us add many locales at once.\r\n     *\r\n     * @see setPrimaryLocale()\r\n     *\r\n     * @param locales A list of locales to be moved to the beginning of the translation priority. First locales item will be the prefered\r\n     *        locale for translation, second will be the next one in case some key is not translated for the first one and so. If any of the\r\n     *        specified locales is not currently loaded, an exception will happen.\r\n     *\r\n     * @returns void\r\n     */\r\n    setPrimaryLocales(locales:string[]){\r\n\r\n        if(!Array.isArray(locales) ||\r\n            (new Set(locales).size !== locales.length) ||\r\n            locales.length === 0){\r\n\r\n                throw new Error('locales must be non empty string array with no duplicate elements');\r\n        }\r\n\r\n        for (let i = locales.length - 1; i >= 0; i--) {\r\n\r\n            this.setPrimaryLocale(locales[i]);\r\n        }\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Define the 2 digit language that will be placed at the front of the currently loaded locales list (moving all the others one position to the right).\r\n     *\r\n     * This will be the first language to use when trying to get a translation.\r\n     *\r\n     * @param language A 2 digit language code that matches with any of the currently loaded locales, which will\r\n     *        be moved to the first position of the loaded locales list. If the specified language does not match with\r\n     *        a locale that is currently loaded, an exception will happen.\r\n     *\r\n     * @returns void\r\n     */\r\n    setPrimaryLanguage(language:string){\r\n\r\n        for(let locale of this._locales){\r\n        \r\n            if(locale.substring(0, 2) === language){\r\n\r\n                this.setPrimaryLocale(locale);\r\n\r\n                return;\r\n            }\r\n        }\r\n\r\n        throw new Error(language + ' not loaded');\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Moves the locales that match the specified languages to the beginning of the locales list.\r\n     * Works the same as setPrimaryLocales() but with a list of the 2 digit language codes that match the respective locales.\r\n     *\r\n     * @see setPrimaryLocale()\r\n     * @see setPrimaryLanguage()\r\n     *\r\n     * @param languages A list of 2 digit language codes to be moved to the beginning of the translation priority. If any of the\r\n     *        specified languages does not match with a locale that is currently loaded, an exception will happen.\r\n     *\r\n     * @returns void\r\n     */\r\n    setPrimaryLanguages(languages:string[]){\r\n\r\n        if(!Array.isArray(languages) ||\r\n           (new Set(languages).size !== languages.length) ||\r\n            languages.length === 0){\r\n\r\n            throw new Error('languages must be non empty string array with no duplicate elements');\r\n        }\r\n\r\n        for (let i = languages.length - 1; i >= 0; i--) {\r\n\r\n            this.setPrimaryLanguage(languages[i]);\r\n        }\r\n    }\r\n    \r\n    \r\n    /**\r\n     * Change the loaded locales translation preference order. The same locales that are currently loaded must be passed\r\n     * but with a different order to change the translation priority.\r\n     *\r\n     * @param locales A list with the new locales translation priority\r\n     *\r\n     * @returns void\r\n     */\r\n    setLocalesOrder(locales:string[]){\r\n\r\n        if(locales.length !== this._locales.length){\r\n\r\n            throw new Error('locales must contain all the currently loaded locales');\r\n        }\r\n\r\n        this._validateInitialized();\r\n\r\n        for(let locale of locales){\r\n        \r\n            if(!this.isLocaleLoaded(locale)){\r\n\r\n                throw new Error(locale + ' not loaded');\r\n            }\r\n        }\r\n\r\n        this._locales = locales;\r\n        this._languages = this._locales.map((l: string) => l.substring(0, 2));\r\n        this._cacheHashBaseString = this._wildCardsFormat + this._missingKeyFormat + this._locales[0];\r\n    }\r\n    \r\n    \r\n    /**\r\n     * This is an aux method to implement the TurboCommons StringUtils replace method.\r\n     * It is exactly the same as the one on the library, but we implement it here to avoid having a dependency with TurboCommons\r\n     */\r\n    private _replace(string: string, search:string, replacement: string) {\r\n        \r\n        const escapedSearch = search.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\r\n           \r\n        return string.replace(new RegExp(escapedSearch, 'g'), replacement);\r\n    }\r\n    \r\n    \r\n    /**\r\n     * This is an aux method to implement the TurboCommons StringUtils isEmpty method.\r\n     * It is exactly the same as the one on the library, but we implement it here to avoid having a dependency with TurboCommons\r\n     */\r\n    private _isEmpty(string:string) {\r\n        \r\n        let isString = (typeof string === 'string' || (string as any) instanceof String);\r\n                \r\n        // Throw exception if non string value was received\r\n        if(!isString){\r\n\r\n            // Empty or null value is considered empty\r\n            if(string == null || string == ''){\r\n    \r\n                return true;\r\n            }\r\n            \r\n            throw new Error(\"value is not a string\");\r\n        }\r\n\r\n        return string.replace(/[ \\n\\r\\t]/g, '') === '';\r\n    }\r\n    \r\n    \r\n    /**\r\n     * This is an aux method to implement the TurboCommons StringUtils forceNonEmptyString method.\r\n     * It is exactly the same as the one on the library, but we implement it here to avoid having a dependency with TurboCommons\r\n     */\r\n    private _forceNonEmptyString(value:any, valueName = '', errorMessage = 'must be a non empty string'){\r\n\r\n        let isString = (typeof value === 'string' || value instanceof String);\r\n        \r\n        if(!isString || this._isEmpty(value)){\r\n\r\n            throw new Error(valueName + ' ' + errorMessage);\r\n        }\r\n    }\r\n}\r\n"]}