@rdkmaster/ngx-translate-core
Version:
Translation library (i18n) for Angular
495 lines • 65.7 kB
JavaScript
import { EventEmitter, Inject, Injectable, InjectionToken } from "@angular/core";
import { concat, forkJoin, isObservable, of, defer } from "rxjs";
import { concatMap, map, shareReplay, switchMap, take } from "rxjs/operators";
import { getValue, isDefined, isArray, isString, mergeDeep, setValue, isDict } from "./util";
import * as i0 from "@angular/core";
import * as i1 from "./translate.store";
import * as i2 from "./translate.loader";
import * as i3 from "./translate.compiler";
import * as i4 from "./translate.parser";
import * as i5 from "./missing-translation-handler";
export const ISOALTE_TRANSLATE_SERVICE = new InjectionToken('ISOALTE_TRANSLATE_SERVICE');
export const USE_DEFAULT_LANG = new InjectionToken('USE_DEFAULT_LANG');
export const DEFAULT_LANGUAGE = new InjectionToken('DEFAULT_LANGUAGE');
export const USE_EXTEND = new InjectionToken('USE_EXTEND');
const makeObservable = (value) => {
return isObservable(value) ? value : of(value);
};
export class TranslateService {
store;
currentLoader;
compiler;
parser;
missingTranslationHandler;
useDefaultLang;
isolate;
extend;
loadingTranslations;
pending = false;
_onTranslationChange = new EventEmitter();
_onLangChange = new EventEmitter();
_onDefaultLangChange = new EventEmitter();
_defaultLang;
_currentLang;
_langs = [];
_translations = {};
_translationRequests = {};
lastUseLanguage = null;
/**
* An EventEmitter to listen to translation change events
* onTranslationChange.subscribe((params: TranslationChangeEvent) => {
* // do something
* });
*/
get onTranslationChange() {
return this.isolate ? this._onTranslationChange : this.store.onTranslationChange;
}
/**
* An EventEmitter to listen to lang change events
* onLangChange.subscribe((params: LangChangeEvent) => {
* // do something
* });
*/
get onLangChange() {
return this.isolate ? this._onLangChange : this.store.onLangChange;
}
/**
* An EventEmitter to listen to default lang change events
* onDefaultLangChange.subscribe((params: DefaultLangChangeEvent) => {
* // do something
* });
*/
get onDefaultLangChange() {
return this.isolate ? this._onDefaultLangChange : this.store.onDefaultLangChange;
}
/**
* The default lang to fallback when translations are missing on the current lang
*/
get defaultLang() {
return this.isolate ? this._defaultLang : this.store.defaultLang;
}
set defaultLang(defaultLang) {
if (this.isolate) {
this._defaultLang = defaultLang;
}
else {
this.store.defaultLang = defaultLang;
}
}
/**
* The lang currently used
*/
get currentLang() {
return this.isolate ? this._currentLang : this.store.currentLang;
}
set currentLang(currentLang) {
if (this.isolate) {
this._currentLang = currentLang;
}
else {
this.store.currentLang = currentLang;
}
}
/**
* an array of langs
*/
get langs() {
return this.isolate ? this._langs : this.store.langs;
}
set langs(langs) {
if (this.isolate) {
this._langs = langs;
}
else {
this.store.langs = langs;
}
}
/**
* a list of translations per lang
*/
get translations() {
return this.isolate ? this._translations : this.store.translations;
}
set translations(translations) {
if (this.isolate) {
this._translations = translations;
}
else {
this.store.translations = translations;
}
}
/**
*
* @param store an instance of the store (that is supposed to be unique)
* @param currentLoader An instance of the loader currently used
* @param compiler An instance of the compiler currently used
* @param parser An instance of the parser currently used
* @param missingTranslationHandler A handler for missing translations.
* @param useDefaultLang whether we should use default language translation when current language translation is missing.
* @param isolate whether this service should use the store or not
* @param extend To make a child module extend (and use) translations from parent modules.
* @param defaultLanguage Set the default language using configuration
*/
constructor(store, currentLoader, compiler, parser, missingTranslationHandler, useDefaultLang = true, isolate = false, extend = false, defaultLanguage) {
this.store = store;
this.currentLoader = currentLoader;
this.compiler = compiler;
this.parser = parser;
this.missingTranslationHandler = missingTranslationHandler;
this.useDefaultLang = useDefaultLang;
this.isolate = isolate;
this.extend = extend;
/** set the default language from configuration */
if (defaultLanguage) {
this.setDefaultLang(defaultLanguage);
}
}
/**
* Sets the default language to use as a fallback
*/
setDefaultLang(lang) {
if (lang === this.defaultLang) {
return;
}
const pending = this.retrieveTranslations(lang);
if (typeof pending !== "undefined") {
// on init set the defaultLang immediately
if (this.defaultLang == null) {
this.defaultLang = lang;
}
pending.pipe(take(1))
.subscribe(() => {
this.changeDefaultLang(lang);
});
}
else { // we already have this language
this.changeDefaultLang(lang);
}
}
/**
* Gets the default language used
*/
getDefaultLang() {
return this.defaultLang;
}
/**
* Changes the lang currently used
*/
use(lang) {
// remember the language that was called
// we need this with multiple fast calls to use()
// where translation loads might complete in random order
this.lastUseLanguage = lang;
// don't change the language if the language given is already selected
if (lang === this.currentLang) {
return of(this.translations[lang]);
}
// on init set the currentLang immediately
if (!this.currentLang) {
this.currentLang = lang;
}
const pending = this.retrieveTranslations(lang);
if (isObservable(pending)) {
pending.pipe(take(1))
.subscribe(() => {
this.changeLang(lang);
});
return pending;
}
else {
// we have this language, return an Observable
this.changeLang(lang);
return of(this.translations[lang]);
}
}
/**
* Changes the current lang
*/
changeLang(lang) {
// received a new language file
// but this was not the one requested last
if (lang !== this.lastUseLanguage) {
return;
}
this.currentLang = lang;
this.onLangChange.emit({ lang: lang, translations: this.translations[lang] });
// if there is no default lang, use the one that we just set
if (this.defaultLang == null) {
this.changeDefaultLang(lang);
}
}
/**
* Retrieves the given translations
*/
retrieveTranslations(lang) {
// if this language is unavailable or extend is true, ask for it
if (typeof this.translations[lang] === "undefined" || this.extend) {
this._translationRequests[lang] = this._translationRequests[lang] || this.loadAndCompileTranslations(lang);
return this._translationRequests[lang];
}
return undefined;
}
/**
* Gets an object of translations for a given language with the current loader
* and passes it through the compiler
*
* @deprecated This function is meant for internal use. There should
* be no reason to use outside this service. You can plug into this
* functionality by using a customer TranslateLoader or TranslateCompiler.
* To load a new language use setDefaultLang() and/or use()
*/
getTranslation(lang) {
return this.loadAndCompileTranslations(lang);
}
loadAndCompileTranslations(lang) {
this.pending = true;
const loadingTranslations = this.currentLoader.getTranslation(lang).pipe(shareReplay(1), take(1));
this.loadingTranslations = loadingTranslations.pipe(map((res) => this.compiler.compileTranslations(res, lang)), shareReplay(1), take(1));
this.loadingTranslations
.subscribe({
next: (res) => {
this.translations[lang] = this.extend && this.translations[lang] ? { ...res, ...this.translations[lang] } : res;
this.updateLangs();
this.pending = false;
},
error: (err) => {
void err;
this.pending = false;
}
});
return loadingTranslations;
}
/**
* Manually sets an object of translations for a given language
* after passing it through the compiler
*/
setTranslation(lang, translations, shouldMerge = false) {
const interpolatableTranslations = this.compiler.compileTranslations(translations, lang);
if ((shouldMerge || this.extend) && this.translations[lang]) {
this.translations[lang] = mergeDeep(this.translations[lang], interpolatableTranslations);
}
else {
this.translations[lang] = interpolatableTranslations;
}
this.updateLangs();
this.onTranslationChange.emit({ lang: lang, translations: this.translations[lang] });
}
/**
* Returns an array of currently available langs
*/
getLangs() {
return this.langs;
}
/**
* Add available languages
*/
addLangs(langs) {
langs.forEach((lang) => {
if (this.langs.indexOf(lang) === -1) {
this.langs.push(lang);
}
});
}
/**
* Update the list of available languages
*/
updateLangs() {
this.addLangs(Object.keys(this.translations));
}
getParsedResultForKey(translations, key, interpolateParams) {
let res;
if (translations) {
res = this.runInterpolation(getValue(translations, key), interpolateParams);
}
if (res === undefined && this.defaultLang != null && this.defaultLang !== this.currentLang && this.useDefaultLang) {
res = this.runInterpolation(getValue(this.translations[this.defaultLang], key), interpolateParams);
}
if (res === undefined) {
const params = { key, translateService: this };
if (typeof interpolateParams !== 'undefined') {
params.interpolateParams = interpolateParams;
}
res = this.missingTranslationHandler.handle(params);
}
return res !== undefined ? res : key;
}
runInterpolation(translations, interpolateParams) {
if (isArray(translations)) {
return translations.map((translation) => this.runInterpolation(translation, interpolateParams));
}
else if (isDict(translations)) {
const result = {};
for (const key in translations) {
result[key] = this.runInterpolation(translations[key], interpolateParams);
}
return result;
}
else {
return this.parser.interpolate(translations, interpolateParams);
}
}
/**
* Returns the parsed result of the translations
*/
getParsedResult(translations, key, interpolateParams) {
// handle a bunch of keys
if (key instanceof Array) {
const result = {};
let observables = false;
for (const k of key) {
result[k] = this.getParsedResultForKey(translations, k, interpolateParams);
observables = observables || isObservable(result[k]);
}
if (!observables) {
return result;
}
const sources = key.map(k => makeObservable(result[k]));
return forkJoin(sources).pipe(map((arr) => {
const obj = {};
arr.forEach((value, index) => {
obj[key[index]] = value;
});
return obj;
}));
}
return this.getParsedResultForKey(translations, key, interpolateParams);
}
/**
* Gets the translated value of a key (or an array of keys)
* @returns the translated key, or an object of translated keys
*/
get(key, interpolateParams) {
if (!isDefined(key) || !key.length) {
throw new Error(`Parameter "key" is required and cannot be empty`);
}
// check if we are loading a new translation to use
if (this.pending) {
return this.loadingTranslations.pipe(concatMap((res) => {
return makeObservable(this.getParsedResult(res, key, interpolateParams));
}));
}
return makeObservable(this.getParsedResult(this.translations[this.currentLang], key, interpolateParams));
}
/**
* Returns a stream of translated values of a key (or an array of keys) which updates
* whenever the translation changes.
* @returns A stream of the translated key, or an object of translated keys
*/
getStreamOnTranslationChange(key, interpolateParams) {
if (!isDefined(key) || !key.length) {
throw new Error(`Parameter "key" is required and cannot be empty`);
}
return concat(defer(() => this.get(key, interpolateParams)), this.onTranslationChange.pipe(switchMap((event) => {
const res = this.getParsedResult(event.translations, key, interpolateParams);
return makeObservable(res);
})));
}
/**
* Returns a stream of translated values of a key (or an array of keys) which updates
* whenever the language changes.
* @returns A stream of the translated key, or an object of translated keys
*/
stream(key, interpolateParams) {
if (!isDefined(key) || !key.length) {
throw new Error(`Parameter "key" required`);
}
return concat(defer(() => this.get(key, interpolateParams)), this.onLangChange.pipe(switchMap((event) => {
const res = this.getParsedResult(event.translations, key, interpolateParams);
return makeObservable(res);
})));
}
/**
* Returns a translation instantly from the internal state of loaded translation.
* All rules regarding the current language, the preferred language of even fallback languages
* will be used except any promise handling.
*/
instant(key, interpolateParams) {
if (!isDefined(key) || key.length === 0) {
throw new Error('Parameter "key" is required and cannot be empty');
}
const result = this.getParsedResult(this.translations[this.currentLang], key, interpolateParams);
if (isObservable(result)) {
if (Array.isArray(key)) {
return key.reduce((acc, currKey) => {
acc[currKey] = currKey;
return acc;
}, {});
}
return key;
}
return result;
}
/**
* Sets the translated value of a key, after compiling it
*/
set(key, translation, lang = this.currentLang) {
setValue(this.translations[lang], key, isString(translation)
? this.compiler.compile(translation, lang)
: this.compiler.compileTranslations(translation, lang));
this.updateLangs();
this.onTranslationChange.emit({ lang: lang, translations: this.translations[lang] });
}
/**
* Changes the default lang
*/
changeDefaultLang(lang) {
this.defaultLang = lang;
this.onDefaultLangChange.emit({ lang: lang, translations: this.translations[lang] });
}
/**
* Allows to reload the lang file from the file
*/
reloadLang(lang) {
this.resetLang(lang);
return this.loadAndCompileTranslations(lang);
}
/**
* Deletes inner translation
*/
resetLang(lang) {
delete this._translationRequests[lang];
delete this.translations[lang];
}
/**
* Returns the language code name from the browser, e.g. "de"
*/
getBrowserLang() {
if (typeof window === 'undefined' || !window.navigator) {
return undefined;
}
const browserLang = this.getBrowserCultureLang();
return browserLang ? browserLang.split(/[-_]/)[0] : undefined;
}
/**
* Returns the culture language code name from the browser, e.g. "de-DE"
*/
getBrowserCultureLang() {
if (typeof window === 'undefined' || typeof window.navigator === 'undefined') {
return undefined;
}
return window.navigator.languages
? window.navigator.languages[0]
: (window.navigator.language || window.navigator.browserLanguage || window.navigator.userLanguage);
}
static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: TranslateService, deps: [{ token: i1.TranslateStore }, { token: i2.TranslateLoader }, { token: i3.TranslateCompiler }, { token: i4.TranslateParser }, { token: i5.MissingTranslationHandler }, { token: USE_DEFAULT_LANG }, { token: ISOALTE_TRANSLATE_SERVICE }, { token: USE_EXTEND }, { token: DEFAULT_LANGUAGE }], target: i0.ɵɵFactoryTarget.Injectable });
static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: TranslateService, providedIn: 'root' });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.10", ngImport: i0, type: TranslateService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}], ctorParameters: () => [{ type: i1.TranslateStore }, { type: i2.TranslateLoader }, { type: i3.TranslateCompiler }, { type: i4.TranslateParser }, { type: i5.MissingTranslationHandler }, { type: undefined, decorators: [{
type: Inject,
args: [USE_DEFAULT_LANG]
}] }, { type: undefined, decorators: [{
type: Inject,
args: [ISOALTE_TRANSLATE_SERVICE]
}] }, { type: undefined, decorators: [{
type: Inject,
args: [USE_EXTEND]
}] }, { type: undefined, decorators: [{
type: Inject,
args: [DEFAULT_LANGUAGE]
}] }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translate.service.js","sourceRoot":"","sources":["../../../../projects/ngx-translate/src/lib/translate.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {EventEmitter, Inject, Injectable, InjectionToken} from \"@angular/core\";\nimport {concat, forkJoin, isObservable, Observable, of, defer} from \"rxjs\";\nimport {concatMap, map, shareReplay, switchMap, take} from \"rxjs/operators\";\nimport {MissingTranslationHandler, MissingTranslationHandlerParams} from \"./missing-translation-handler\";\nimport {TranslateCompiler} from \"./translate.compiler\";\nimport {TranslateLoader} from \"./translate.loader\";\nimport {InterpolateFunction, TranslateParser} from \"./translate.parser\";\nimport {TranslateStore} from \"./translate.store\";\nimport {getValue, isDefined, isArray, isString, mergeDeep, setValue, isDict} from \"./util\";\n\nexport const ISOALTE_TRANSLATE_SERVICE = new InjectionToken<string>('ISOALTE_TRANSLATE_SERVICE');\nexport const USE_DEFAULT_LANG = new InjectionToken<string>('USE_DEFAULT_LANG');\nexport const DEFAULT_LANGUAGE = new InjectionToken<string>('DEFAULT_LANGUAGE');\nexport const USE_EXTEND = new InjectionToken<string>('USE_EXTEND');\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type InterpolationParameters = Record<string, any>;\n\nexport type Translation =\n  string |\n  Translation[] |\n  TranslationObject |\n\n  // required to prevent error \"Type instantiation is excessively deep and possibly infinite.\"\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any\n  ;\n\n\n// using Record<> does not work because TS does not support recursive definitions\n// eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style\nexport interface TranslationObject {\n  [key: string]: Translation\n}\n\n\nexport type InterpolatableTranslation =\n  string |\n  InterpolatableTranslation[] |\n  InterpolateFunction |\n  InterpolatableTranslationObject |\n\n  // required to prevent error \"Type instantiation is excessively deep and possibly infinite.\"\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any\n  ;\n\n\n// using Record<> does not work because TS does not support recursive definitions\n// eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style\nexport interface InterpolatableTranslationObject {\n  [key: string]: InterpolatableTranslation\n}\n\n\nexport type Language = string;\n\nexport interface TranslationChangeEvent {\n  translations: InterpolatableTranslationObject;\n  lang: string;\n}\n\nexport interface LangChangeEvent {\n  lang: string;\n  translations: InterpolatableTranslationObject;\n}\n\nexport interface DefaultLangChangeEvent {\n  lang: string;\n  translations: InterpolatableTranslationObject;\n}\n\ndeclare interface Window {\n  navigator: {\n    languages?: string[],\n    language?: string,\n    browserLanguage?: string,\n    userLanguage?: string,\n  };\n}\n\ndeclare const window: Window;\n\nconst makeObservable = <T>(value: T | Observable<T>): Observable<T> => {\n  return isObservable(value) ? value : of(value);\n};\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class TranslateService {\n  private loadingTranslations!: Observable<InterpolatableTranslationObject>;\n  private pending = false;\n  private _onTranslationChange: EventEmitter<TranslationChangeEvent> = new EventEmitter<TranslationChangeEvent>();\n  private _onLangChange: EventEmitter<LangChangeEvent> = new EventEmitter<LangChangeEvent>();\n  private _onDefaultLangChange: EventEmitter<DefaultLangChangeEvent> = new EventEmitter<DefaultLangChangeEvent>();\n  private _defaultLang!: string;\n  private _currentLang!: string;\n  private _langs: string[] = [];\n  private _translations: Record<string, InterpolatableTranslationObject> = {};\n  private _translationRequests: Record<string, Observable<TranslationObject>> = {};\n  private lastUseLanguage: string|null = null;\n\n\n  /**\n   * An EventEmitter to listen to translation change events\n   * onTranslationChange.subscribe((params: TranslationChangeEvent) => {\n     *     // do something\n     * });\n   */\n  get onTranslationChange(): EventEmitter<TranslationChangeEvent> {\n    return this.isolate ? this._onTranslationChange : this.store.onTranslationChange;\n  }\n\n  /**\n   * An EventEmitter to listen to lang change events\n   * onLangChange.subscribe((params: LangChangeEvent) => {\n     *     // do something\n     * });\n   */\n  get onLangChange(): EventEmitter<LangChangeEvent> {\n    return this.isolate ? this._onLangChange : this.store.onLangChange;\n  }\n\n  /**\n   * An EventEmitter to listen to default lang change events\n   * onDefaultLangChange.subscribe((params: DefaultLangChangeEvent) => {\n     *     // do something\n     * });\n   */\n  get onDefaultLangChange() {\n    return this.isolate ? this._onDefaultLangChange : this.store.onDefaultLangChange;\n  }\n\n  /**\n   * The default lang to fallback when translations are missing on the current lang\n   */\n  get defaultLang(): string {\n    return this.isolate ? this._defaultLang : this.store.defaultLang;\n  }\n\n  set defaultLang(defaultLang: string) {\n    if (this.isolate) {\n      this._defaultLang = defaultLang;\n    } else {\n      this.store.defaultLang = defaultLang;\n    }\n  }\n\n  /**\n   * The lang currently used\n   */\n  get currentLang(): string {\n    return this.isolate ? this._currentLang : this.store.currentLang;\n  }\n\n  set currentLang(currentLang: string) {\n    if (this.isolate) {\n      this._currentLang = currentLang;\n    } else {\n      this.store.currentLang = currentLang;\n    }\n  }\n\n  /**\n   * an array of langs\n   */\n  get langs(): string[] {\n    return this.isolate ? this._langs : this.store.langs;\n  }\n\n  set langs(langs: string[]) {\n    if (this.isolate) {\n      this._langs = langs;\n    } else {\n      this.store.langs = langs;\n    }\n  }\n\n  /**\n   * a list of translations per lang\n   */\n  get translations(): Record<string, InterpolatableTranslationObject> {\n    return this.isolate ? this._translations : this.store.translations;\n  }\n\n  set translations(translations: Record<string, InterpolatableTranslationObject>) {\n    if (this.isolate) {\n      this._translations = translations;\n    } else {\n      this.store.translations = translations;\n    }\n  }\n\n  /**\n   *\n   * @param store an instance of the store (that is supposed to be unique)\n   * @param currentLoader An instance of the loader currently used\n   * @param compiler An instance of the compiler currently used\n   * @param parser An instance of the parser currently used\n   * @param missingTranslationHandler A handler for missing translations.\n   * @param useDefaultLang whether we should use default language translation when current language translation is missing.\n   * @param isolate whether this service should use the store or not\n   * @param extend To make a child module extend (and use) translations from parent modules.\n   * @param defaultLanguage Set the default language using configuration\n   */\n  constructor(public store: TranslateStore,\n              public currentLoader: TranslateLoader,\n              public compiler: TranslateCompiler,\n              public parser: TranslateParser,\n              public missingTranslationHandler: MissingTranslationHandler,\n              @Inject(USE_DEFAULT_LANG) private useDefaultLang = true,\n              @Inject(ISOALTE_TRANSLATE_SERVICE) private isolate = false,\n              @Inject(USE_EXTEND) private extend = false,\n              @Inject(DEFAULT_LANGUAGE) defaultLanguage: string) {\n    /** set the default language from configuration */\n    if (defaultLanguage) {\n      this.setDefaultLang(defaultLanguage);\n    }\n  }\n\n  /**\n   * Sets the default language to use as a fallback\n   */\n  public setDefaultLang(lang: string): void {\n    if (lang === this.defaultLang) {\n      return;\n    }\n\n    const pending = this.retrieveTranslations(lang);\n\n    if (typeof pending !== \"undefined\") {\n      // on init set the defaultLang immediately\n      if (this.defaultLang == null) {\n        this.defaultLang = lang;\n      }\n\n      pending.pipe(take(1))\n        .subscribe(() => {\n          this.changeDefaultLang(lang);\n        });\n    } else { // we already have this language\n      this.changeDefaultLang(lang);\n    }\n  }\n\n  /**\n   * Gets the default language used\n   */\n  public getDefaultLang(): string {\n    return this.defaultLang;\n  }\n\n  /**\n   * Changes the lang currently used\n   */\n  public use(lang: string): Observable<InterpolatableTranslationObject> {\n\n    // remember the language that was called\n    // we need this with multiple fast calls to use()\n    // where translation loads might complete in random order\n    this.lastUseLanguage = lang;\n\n    // don't change the language if the language given is already selected\n    if (lang === this.currentLang) {\n      return of(this.translations[lang]);\n    }\n\n    // on init set the currentLang immediately\n    if (!this.currentLang) {\n      this.currentLang = lang;\n    }\n\n    const pending = this.retrieveTranslations(lang);\n\n    if (isObservable(pending)) {\n\n      pending.pipe(take(1))\n        .subscribe(() => {\n          this.changeLang(lang);\n        });\n\n      return pending;\n    }\n    else {\n      // we have this language, return an Observable\n      this.changeLang(lang);\n      return of(this.translations[lang]);\n    }\n  }\n\n\n  /**\n   * Changes the current lang\n   */\n  private changeLang(lang: string): void {\n\n    // received a new language file\n    // but this was not the one requested last\n    if(lang !== this.lastUseLanguage)\n    {\n      return;\n    }\n\n    this.currentLang = lang;\n\n    this.onLangChange.emit({lang: lang, translations: this.translations[lang]});\n\n    // if there is no default lang, use the one that we just set\n    if (this.defaultLang == null) {\n      this.changeDefaultLang(lang);\n    }\n  }\n\n\n  /**\n   * Retrieves the given translations\n   */\n  private retrieveTranslations(lang: string): Observable<TranslationObject> | undefined {\n\n    // if this language is unavailable or extend is true, ask for it\n    if (typeof this.translations[lang] === \"undefined\" || this.extend) {\n      this._translationRequests[lang] = this._translationRequests[lang] || this.loadAndCompileTranslations(lang);\n      return this._translationRequests[lang];\n    }\n\n    return undefined;\n  }\n\n\n\n  /**\n   * Gets an object of translations for a given language with the current loader\n   * and passes it through the compiler\n   *\n   * @deprecated This function is meant for internal use. There should\n   * be no reason to use outside this service. You can plug into this\n   * functionality by using a customer TranslateLoader or TranslateCompiler.\n   * To load a new language use setDefaultLang() and/or use()\n   */\n  public getTranslation(lang: string): Observable<InterpolatableTranslationObject>\n  {\n      return this.loadAndCompileTranslations(lang);\n  }\n\n  private loadAndCompileTranslations(lang: string): Observable<InterpolatableTranslationObject> {\n\n    this.pending = true;\n\n    const loadingTranslations = this.currentLoader.getTranslation(lang).pipe(\n      shareReplay(1),\n      take(1),\n    );\n\n    this.loadingTranslations = loadingTranslations.pipe(\n      map((res:TranslationObject) => this.compiler.compileTranslations(res, lang)),\n      shareReplay(1),\n      take(1),\n    );\n\n    this.loadingTranslations\n      .subscribe({\n        next: (res: InterpolatableTranslationObject) => {\n          this.translations[lang] = this.extend && this.translations[lang] ? { ...res, ...this.translations[lang] } : res;\n          this.updateLangs();\n          this.pending = false;\n        },\n        error: (err) => {\n          void err;\n          this.pending = false;\n        }\n      });\n\n    return loadingTranslations;\n  }\n\n  /**\n   * Manually sets an object of translations for a given language\n   * after passing it through the compiler\n   */\n  public setTranslation(lang: string, translations: InterpolatableTranslationObject, shouldMerge = false): void {\n    const interpolatableTranslations = this.compiler.compileTranslations(translations, lang);\n    if ((shouldMerge || this.extend) && this.translations[lang]) {\n      this.translations[lang] = mergeDeep(this.translations[lang], interpolatableTranslations);\n    } else {\n      this.translations[lang] = interpolatableTranslations;\n    }\n    this.updateLangs();\n    this.onTranslationChange.emit({lang: lang, translations: this.translations[lang]});\n  }\n\n  /**\n   * Returns an array of currently available langs\n   */\n  public getLangs(): string[] {\n    return this.langs;\n  }\n\n  /**\n   * Add available languages\n   */\n  public addLangs(langs: string[]): void {\n    langs.forEach((lang: string) => {\n      if (this.langs.indexOf(lang) === -1) {\n        this.langs.push(lang);\n      }\n    });\n  }\n\n  /**\n   * Update the list of available languages\n   */\n  private updateLangs(): void {\n    this.addLangs(Object.keys(this.translations));\n  }\n\n  private getParsedResultForKey(translations: InterpolatableTranslation, key: string, interpolateParams?: InterpolationParameters): Translation|Observable<Translation>\n  {\n      let res: Translation | Observable<Translation> | undefined;\n\n      if (translations) {\n        res = this.runInterpolation(getValue(translations, key), interpolateParams);\n      }\n\n      if (res === undefined && this.defaultLang != null && this.defaultLang !== this.currentLang && this.useDefaultLang) {\n        res = this.runInterpolation(getValue(this.translations[this.defaultLang], key), interpolateParams);\n      }\n\n      if (res === undefined) {\n        const params: MissingTranslationHandlerParams = {key, translateService: this};\n        if (typeof interpolateParams !== 'undefined') {\n          params.interpolateParams = interpolateParams;\n        }\n        res = this.missingTranslationHandler.handle(params);\n      }\n\n      return res !== undefined ? res : key;\n  }\n\n  private runInterpolation(translations: InterpolatableTranslation, interpolateParams?: InterpolationParameters): Translation\n  {\n    if(isArray(translations))\n    {\n      return (translations as Translation[]).map((translation) => this.runInterpolation(translation, interpolateParams));\n    }\n    else if (isDict(translations))\n    {\n      const result: TranslationObject = {};\n      for (const key in translations) {\n          result[key] = this.runInterpolation(translations[key], interpolateParams);\n      }\n      return result;\n    }\n    else\n    {\n      return this.parser.interpolate(translations, interpolateParams);\n    }\n  }\n\n  /**\n   * Returns the parsed result of the translations\n   */\n  public getParsedResult(translations: InterpolatableTranslation, key: string | string[], interpolateParams?: InterpolationParameters): Translation|TranslationObject|Observable<Translation|TranslationObject> {\n\n    // handle a bunch of keys\n    if (key instanceof Array) {\n      const result: Record<string, Translation|Observable<Translation>> = {};\n\n      let observables = false;\n      for (const k of key) {\n        result[k] = this.getParsedResultForKey(translations, k, interpolateParams);\n        observables = observables || isObservable(result[k]);\n      }\n\n      if (!observables) {\n        return result as TranslationObject;\n      }\n\n      const sources: Observable<Translation>[] = key.map(k => makeObservable(result[k]));\n      return forkJoin(sources).pipe(\n        map((arr: (Translation)[]) => {\n          const obj: TranslationObject = {};\n          arr.forEach((value:Translation, index: number) => {\n            obj[key[index]] = value;\n          });\n          return obj;\n        })\n      );\n    }\n\n    return this.getParsedResultForKey(translations, key, interpolateParams);\n  }\n\n  /**\n   * Gets the translated value of a key (or an array of keys)\n   * @returns the translated key, or an object of translated keys\n   */\n  public get(key: string | string[], interpolateParams?: InterpolationParameters): Observable<Translation|TranslationObject> {\n    if (!isDefined(key) || !key.length) {\n      throw new Error(`Parameter \"key\" is required and cannot be empty`);\n    }\n    // check if we are loading a new translation to use\n    if (this.pending) {\n      return this.loadingTranslations.pipe(\n        concatMap((res: InterpolatableTranslation) => {\n          return makeObservable(this.getParsedResult(res, key, interpolateParams));\n        }),\n      );\n    }\n\n    return makeObservable(this.getParsedResult(this.translations[this.currentLang], key, interpolateParams));\n  }\n\n  /**\n   * Returns a stream of translated values of a key (or an array of keys) which updates\n   * whenever the translation changes.\n   * @returns A stream of the translated key, or an object of translated keys\n   */\n  public getStreamOnTranslationChange(key: string | string[], interpolateParams?: InterpolationParameters): Observable<Translation|TranslationObject> {\n    if (!isDefined(key) || !key.length) {\n      throw new Error(`Parameter \"key\" is required and cannot be empty`);\n    }\n\n    return concat(\n      defer(() => this.get(key, interpolateParams)),\n      this.onTranslationChange.pipe(\n        switchMap((event: TranslationChangeEvent) => {\n          const res = this.getParsedResult(event.translations, key, interpolateParams);\n          return makeObservable(res);\n        })\n      )\n    );\n  }\n\n  /**\n   * Returns a stream of translated values of a key (or an array of keys) which updates\n   * whenever the language changes.\n   * @returns A stream of the translated key, or an object of translated keys\n   */\n  public stream(key: string | string[], interpolateParams?: InterpolationParameters): Observable<Translation|TranslationObject> {\n    if (!isDefined(key) || !key.length) {\n      throw new Error(`Parameter \"key\" required`);\n    }\n\n    return concat(\n      defer(() => this.get(key, interpolateParams)),\n      this.onLangChange.pipe(\n        switchMap((event: LangChangeEvent) => {\n          const res = this.getParsedResult(event.translations, key, interpolateParams);\n          return makeObservable(res);\n        })\n      ));\n  }\n\n  /**\n   * Returns a translation instantly from the internal state of loaded translation.\n   * All rules regarding the current language, the preferred language of even fallback languages\n   * will be used except any promise handling.\n   */\n  public instant(key: string | string[], interpolateParams?: InterpolationParameters): Translation|TranslationObject\n  {\n    if (!isDefined(key) || key.length === 0) {\n      throw new Error('Parameter \"key\" is required and cannot be empty');\n    }\n\n    const result = this.getParsedResult(this.translations[this.currentLang], key, interpolateParams);\n\n    if (isObservable(result)) {\n      if (Array.isArray(key)) {\n        return key.reduce((acc: Record<string, string>, currKey: string) => {\n          acc[currKey] = currKey;\n          return acc;\n        }, {});\n      }\n      return key;\n    }\n\n    return result;\n  }\n\n  /**\n   * Sets the translated value of a key, after compiling it\n   */\n  public set(key: string, translation: Translation, lang: string = this.currentLang): void {\n    setValue(this.translations[lang], key,\n      isString(translation)\n      ? this.compiler.compile(translation, lang)\n      : this.compiler.compileTranslations(translation, lang)\n    );\n    this.updateLangs();\n    this.onTranslationChange.emit({lang: lang, translations: this.translations[lang]});\n  }\n\n  /**\n   * Changes the default lang\n   */\n  private changeDefaultLang(lang: string): void {\n    this.defaultLang = lang;\n    this.onDefaultLangChange.emit({lang: lang, translations: this.translations[lang]});\n  }\n\n  /**\n   * Allows to reload the lang file from the file\n   */\n  public reloadLang(lang: string): Observable<InterpolatableTranslationObject> {\n    this.resetLang(lang);\n    return this.loadAndCompileTranslations(lang);\n  }\n\n  /**\n   * Deletes inner translation\n   */\n  public resetLang(lang: string): void {\n    delete this._translationRequests[lang];\n    delete this.translations[lang];\n  }\n\n  /**\n   * Returns the language code name from the browser, e.g. \"de\"\n   */\n  public getBrowserLang(): string | undefined {\n    if (typeof window === 'undefined' || !window.navigator) {\n      return undefined;\n    }\n\n    const browserLang = this.getBrowserCultureLang();\n\n    return browserLang ? browserLang.split(/[-_]/)[0] : undefined;\n  }\n\n  /**\n   * Returns the culture language code name from the browser, e.g. \"de-DE\"\n   */\n  public getBrowserCultureLang(): string | undefined {\n    if (typeof window === 'undefined' || typeof window.navigator === 'undefined') {\n      return undefined;\n    }\n\n    return window.navigator.languages\n             ? window.navigator.languages[0]\n             : (window.navigator.language || window.navigator.browserLanguage || window.navigator.userLanguage);\n  }\n}\n"]}