@jsverse/transloco 7.0.0

package/esm2022/lib/transloco.service.mjs

@@ -0,0 +1,579 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { BehaviorSubject, catchError, combineLatest, EMPTY, forkJoin, from, map, of, retry, shareReplay, Subject, switchMap, tap, } from 'rxjs';
+import { DefaultLoader, TRANSLOCO_LOADER, } from './transloco.loader';
+import { TRANSLOCO_TRANSPILER, } from './transloco.transpiler';
+import { flatten, isEmpty, isNil, isScopeArray, isScopeObject, isString, size, toCamelCase, unflatten, } from './helpers';
+import { TRANSLOCO_CONFIG } from './transloco.config';
+import { TRANSLOCO_MISSING_HANDLER, } from './transloco-missing-handler';
+import { TRANSLOCO_INTERCEPTOR, } from './transloco.interceptor';
+import { TRANSLOCO_FALLBACK_STRATEGY, } from './transloco-fallback-strategy';
+import { getEventPayload, getLangFromScope, getScopeFromLang, resolveInlineLoader, } from './shared';
+import { getFallbacksLoaders } from './get-fallbacks-loaders';
+import { resolveLoader } from './resolve-loader';
+import * as i0 from "@angular/core";
+let service;
+export function translate(key, params = {}, lang) {
+    return service.translate(key, params, lang);
+}
+export function translateObject(key, params = {}, lang) {
+    return service.translateObject(key, params, lang);
+}
+export class TranslocoService {
+    loader;
+    parser;
+    missingHandler;
+    interceptor;
+    fallbackStrategy;
+    langChanges$;
+    subscription = null;
+    translations = new Map();
+    cache = new Map();
+    firstFallbackLang;
+    defaultLang = '';
+    availableLangs = [];
+    isResolvedMissingOnce = false;
+    lang;
+    failedLangs = new Set();
+    events = new Subject();
+    events$ = this.events.asObservable();
+    config;
+    constructor(loader, parser, missingHandler, interceptor, userConfig, fallbackStrategy) {
+        this.loader = loader;
+        this.parser = parser;
+        this.missingHandler = missingHandler;
+        this.interceptor = interceptor;
+        this.fallbackStrategy = fallbackStrategy;
+        if (!this.loader) {
+            this.loader = new DefaultLoader(this.translations);
+        }
+        service = this;
+        this.config = JSON.parse(JSON.stringify(userConfig));
+        this.setAvailableLangs(this.config.availableLangs || []);
+        this.setFallbackLangForMissingTranslation(this.config);
+        this.setDefaultLang(this.config.defaultLang);
+        this.lang = new BehaviorSubject(this.getDefaultLang());
+        // Don't use distinctUntilChanged as we need the ability to update
+        // the value when using setTranslation or setTranslationKeys
+        this.langChanges$ = this.lang.asObservable();
+        /**
+         * When we have a failure, we want to define the next language that succeeded as the active
+         */
+        this.subscription = this.events$.subscribe((e) => {
+            if (e.type === 'translationLoadSuccess' && e.wasFailure) {
+                this.setActiveLang(e.payload.langName);
+            }
+        });
+    }
+    getDefaultLang() {
+        return this.defaultLang;
+    }
+    setDefaultLang(lang) {
+        this.defaultLang = lang;
+    }
+    getActiveLang() {
+        return this.lang.getValue();
+    }
+    setActiveLang(lang) {
+        this.parser.onLangChanged?.(lang);
+        this.lang.next(lang);
+        this.events.next({
+            type: 'langChanged',
+            payload: getEventPayload(lang),
+        });
+        return this;
+    }
+    setAvailableLangs(langs) {
+        this.availableLangs = langs;
+    }
+    /**
+     * Gets the available languages.
+     *
+     * @returns
+     * An array of the available languages. Can be either a `string[]` or a `{ id: string; label: string }[]`
+     * depending on how the available languages are set in your module.
+     */
+    getAvailableLangs() {
+        return this.availableLangs;
+    }
+    load(path, options = {}) {
+        const cached = this.cache.get(path);
+        if (cached) {
+            return cached;
+        }
+        let loadTranslation;
+        const isScope = this._isLangScoped(path);
+        let scope;
+        if (isScope) {
+            scope = getScopeFromLang(path);
+        }
+        const loadersOptions = {
+            path,
+            mainLoader: this.loader,
+            inlineLoader: options.inlineLoader,
+            data: isScope ? { scope: scope } : undefined,
+        };
+        if (this.useFallbackTranslation(path)) {
+            // if the path is scope the fallback should be `scope/fallbackLang`;
+            const fallback = isScope
+                ? `${scope}/${this.firstFallbackLang}`
+                : this.firstFallbackLang;
+            const loaders = getFallbacksLoaders({
+                ...loadersOptions,
+                fallbackPath: fallback,
+            });
+            loadTranslation = forkJoin(loaders);
+        }
+        else {
+            const loader = resolveLoader(loadersOptions);
+            loadTranslation = from(loader);
+        }
+        const load$ = loadTranslation.pipe(retry(this.config.failedRetries), tap((translation) => {
+            if (Array.isArray(translation)) {
+                translation.forEach((t) => {
+                    this.handleSuccess(t.lang, t.translation);
+                    // Save the fallback in cache so we'll not create a redundant request
+                    if (t.lang !== path) {
+                        this.cache.set(t.lang, of({}));
+                    }
+                });
+                return;
+            }
+            this.handleSuccess(path, translation);
+        }), catchError((error) => {
+            if (!this.config.prodMode) {
+                console.error(`Error while trying to load "${path}"`, error);
+            }
+            return this.handleFailure(path, options);
+        }), shareReplay(1));
+        this.cache.set(path, load$);
+        return load$;
+    }
+    /**
+     * Gets the instant translated value of a key
+     *
+     * @example
+     *
+     * translate<string>('hello')
+     * translate('hello', { value: 'value' })
+     * translate<string[]>(['hello', 'key'])
+     * translate('hello', { }, 'en')
+     * translate('scope.someKey', { }, 'en')
+     */
+    translate(key, params = {}, lang = this.getActiveLang()) {
+        if (!key)
+            return key;
+        const { scope, resolveLang } = this.resolveLangAndScope(lang);
+        if (Array.isArray(key)) {
+            return key.map((k) => this.translate(scope ? `${scope}.${k}` : k, params, resolveLang));
+        }
+        key = scope ? `${scope}.${key}` : key;
+        const translation = this.getTranslation(resolveLang);
+        const value = translation[key];
+        if (!value) {
+            return this._handleMissingKey(key, value, params);
+        }
+        return this.parser.transpile({
+            value, params, translation, key
+        });
+    }
+    /**
+     * Gets the translated value of a key as observable
+     *
+     * @example
+     *
+     * selectTranslate<string>('hello').subscribe(value => ...)
+     * selectTranslate<string>('hello', {}, 'es').subscribe(value => ...)
+     * selectTranslate<string>('hello', {}, 'todos').subscribe(value => ...)
+     * selectTranslate<string>('hello', {}, { scope: 'todos' }).subscribe(value => ...)
+     *
+     */
+    selectTranslate(key, params, lang, _isObject = false) {
+        let inlineLoader;
+        const load = (lang, options) => this.load(lang, options).pipe(map(() => _isObject
+            ? this.translateObject(key, params, lang)
+            : this.translate(key, params, lang)));
+        if (isNil(lang)) {
+            return this.langChanges$.pipe(switchMap((lang) => load(lang)));
+        }
+        if (isScopeArray(lang) || isScopeObject(lang)) {
+            // it's a scope object.
+            const providerScope = Array.isArray(lang) ? lang[0] : lang;
+            lang = providerScope.scope;
+            inlineLoader = resolveInlineLoader(providerScope, providerScope.scope);
+        }
+        lang = lang;
+        if (this.isLang(lang) || this.isScopeWithLang(lang)) {
+            return load(lang);
+        }
+        // it's a scope
+        const scope = lang;
+        return this.langChanges$.pipe(switchMap((lang) => load(`${scope}/${lang}`, { inlineLoader })));
+    }
+    /**
+     * Whether the scope with lang
+     *
+     * @example
+     *
+     * todos/en => true
+     * todos => false
+     */
+    isScopeWithLang(lang) {
+        return this.isLang(getLangFromScope(lang));
+    }
+    translateObject(key, params = {}, lang = this.getActiveLang()) {
+        if (isString(key) || Array.isArray(key)) {
+            const { resolveLang, scope } = this.resolveLangAndScope(lang);
+            if (Array.isArray(key)) {
+                return key.map((k) => this.translateObject(scope ? `${scope}.${k}` : k, params, resolveLang));
+            }
+            const translation = this.getTranslation(resolveLang);
+            key = scope ? `${scope}.${key}` : key;
+            const value = unflatten(this.getObjectByKey(translation, key));
+            /* If an empty object was returned we want to try and translate the key as a string and not an object */
+            return isEmpty(value)
+                ? this.translate(key, params, lang)
+                : this.parser.transpile({ value, params: params, translation, key });
+        }
+        const translations = [];
+        for (const [_key, _params] of this.getEntries(key)) {
+            translations.push(this.translateObject(_key, _params, lang));
+        }
+        return translations;
+    }
+    selectTranslateObject(key, params, lang) {
+        if (isString(key) || Array.isArray(key)) {
+            return this.selectTranslate(key, params, lang, true);
+        }
+        const [[firstKey, firstParams], ...rest] = this.getEntries(key);
+        /* In order to avoid subscribing multiple times to the load language event by calling selectTranslateObject for each pair,
+         * we listen to when the first key has been translated (the language is loaded) and translate the rest synchronously */
+        return this.selectTranslateObject(firstKey, firstParams, lang).pipe(map((value) => {
+            const translations = [value];
+            for (const [_key, _params] of rest) {
+                translations.push(this.translateObject(_key, _params, lang));
+            }
+            return translations;
+        }));
+    }
+    getTranslation(langOrScope) {
+        if (langOrScope) {
+            if (this.isLang(langOrScope)) {
+                return this.translations.get(langOrScope) || {};
+            }
+            else {
+                // This is a scope, build the scope value from the translation object
+                const { scope, resolveLang } = this.resolveLangAndScope(langOrScope);
+                const translation = this.translations.get(resolveLang) || {};
+                return this.getObjectByKey(translation, scope);
+            }
+        }
+        return this.translations;
+    }
+    /**
+     * Gets an object of translations for a given language
+     *
+     * @example
+     *
+     * selectTranslation().subscribe() - will return the current lang translation
+     * selectTranslation('es').subscribe()
+     * selectTranslation('admin-page').subscribe() - will return the current lang scope translation
+     * selectTranslation('admin-page/es').subscribe()
+     */
+    selectTranslation(lang) {
+        let language$ = this.langChanges$;
+        if (lang) {
+            const scopeLangSpecified = getLangFromScope(lang) !== lang;
+            if (this.isLang(lang) || scopeLangSpecified) {
+                language$ = of(lang);
+            }
+            else {
+                language$ = this.langChanges$.pipe(map((currentLang) => `${lang}/${currentLang}`));
+            }
+        }
+        return language$.pipe(switchMap((language) => this.load(language).pipe(map(() => this.getTranslation(language)))));
+    }
+    /**
+     * Sets or merge a given translation object to current lang
+     *
+     * @example
+     *
+     * setTranslation({ ... })
+     * setTranslation({ ... }, 'en')
+     * setTranslation({ ... }, 'es', { merge: false } )
+     * setTranslation({ ... }, 'todos/en', { merge: false } )
+     */
+    setTranslation(translation, lang = this.getActiveLang(), options = {}) {
+        const defaults = { merge: true, emitChange: true };
+        const mergedOptions = { ...defaults, ...options };
+        const scope = getScopeFromLang(lang);
+        /**
+         * If this isn't a scope we use the whole translation as is
+         * otherwise we need to flat the scope and use it
+         */
+        let flattenScopeOrTranslation = translation;
+        // Merged the scoped language into the active language
+        if (scope) {
+            const key = this.getMappedScope(scope);
+            flattenScopeOrTranslation = flatten({ [key]: translation });
+        }
+        const currentLang = scope ? getLangFromScope(lang) : lang;
+        const mergedTranslation = {
+            ...(mergedOptions.merge && this.getTranslation(currentLang)),
+            ...flattenScopeOrTranslation,
+        };
+        const flattenTranslation = this.config.flatten.aot
+            ? mergedTranslation
+            : flatten(mergedTranslation);
+        const withHook = this.interceptor.preSaveTranslation(flattenTranslation, currentLang);
+        this.translations.set(currentLang, withHook);
+        mergedOptions.emitChange && this.setActiveLang(this.getActiveLang());
+    }
+    /**
+     * Sets translation key with given value
+     *
+     * @example
+     *
+     * setTranslationKey('key', 'value')
+     * setTranslationKey('key.nested', 'value')
+     * setTranslationKey('key.nested', 'value', 'en')
+     * setTranslationKey('key.nested', 'value', 'en', { emitChange: false } )
+     */
+    setTranslationKey(key, value, options = {}) {
+        const lang = options.lang || this.getActiveLang();
+        const withHook = this.interceptor.preSaveTranslationKey(key, value, lang);
+        const newValue = {
+            [key]: withHook,
+        };
+        this.setTranslation(newValue, lang, { ...options, merge: true });
+    }
+    /**
+     * Sets the fallback lang for the currently active language
+     * @param fallbackLang
+     */
+    setFallbackLangForMissingTranslation({ fallbackLang, }) {
+        const lang = Array.isArray(fallbackLang) ? fallbackLang[0] : fallbackLang;
+        if (fallbackLang && this.useFallbackTranslation(lang)) {
+            this.firstFallbackLang = lang;
+        }
+    }
+    /**
+     * @internal
+     */
+    _handleMissingKey(key, value, params) {
+        if (this.config.missingHandler.allowEmpty && value === '') {
+            return '';
+        }
+        if (!this.isResolvedMissingOnce && this.useFallbackTranslation()) {
+            // We need to set it to true to prevent a loop
+            this.isResolvedMissingOnce = true;
+            const fallbackValue = this.translate(key, params, this.firstFallbackLang);
+            this.isResolvedMissingOnce = false;
+            return fallbackValue;
+        }
+        return this.missingHandler.handle(key, this.getMissingHandlerData(), params);
+    }
+    /**
+     * @internal
+     */
+    _isLangScoped(lang) {
+        return this.getAvailableLangsIds().indexOf(lang) === -1;
+    }
+    /**
+     * Checks if a given string is one of the specified available languages.
+     * @returns
+     * True if the given string is an available language.
+     * False if the given string is not an available language.
+     */
+    isLang(lang) {
+        return this.getAvailableLangsIds().indexOf(lang) !== -1;
+    }
+    /**
+     * @internal
+     *
+     * We always want to make sure the global lang is loaded
+     * before loading the scope since you can access both via the pipe/directive.
+     */
+    _loadDependencies(path, inlineLoader) {
+        const mainLang = getLangFromScope(path);
+        if (this._isLangScoped(path) && !this.isLoadedTranslation(mainLang)) {
+            return combineLatest([
+                this.load(mainLang),
+                this.load(path, { inlineLoader }),
+            ]);
+        }
+        return this.load(path, { inlineLoader });
+    }
+    /**
+     * @internal
+     */
+    _completeScopeWithLang(langOrScope) {
+        if (this._isLangScoped(langOrScope) &&
+            !this.isLang(getLangFromScope(langOrScope))) {
+            return `${langOrScope}/${this.getActiveLang()}`;
+        }
+        return langOrScope;
+    }
+    /**
+     * @internal
+     */
+    _setScopeAlias(scope, alias) {
+        if (!this.config.scopeMapping) {
+            this.config.scopeMapping = {};
+        }
+        this.config.scopeMapping[scope] = alias;
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+            // Caretaker note: it's important to clean up references to subscriptions since they save the `next`
+            // callback within its `destination` property, preventing classes from being GC'd.
+            this.subscription = null;
+        }
+        // Caretaker note: since this is the root provider, it'll be destroyed when the `NgModuleRef.destroy()` is run.
+        // Cached values capture `this`, thus leading to a circular reference and preventing the `TranslocoService` from
+        // being GC'd. This would lead to a memory leak when server-side rendering is used since the service is created
+        // and destroyed per each HTTP request, but any service is not getting GC'd.
+        this.cache.clear();
+    }
+    isLoadedTranslation(lang) {
+        return size(this.getTranslation(lang));
+    }
+    getAvailableLangsIds() {
+        const first = this.getAvailableLangs()[0];
+        if (isString(first)) {
+            return this.getAvailableLangs();
+        }
+        return this.getAvailableLangs().map((l) => l.id);
+    }
+    getMissingHandlerData() {
+        return {
+            ...this.config,
+            activeLang: this.getActiveLang(),
+            availableLangs: this.availableLangs,
+            defaultLang: this.defaultLang,
+        };
+    }
+    /**
+     * Use a fallback translation set for missing keys of the primary language
+     * This is unrelated to the fallback language (which changes the active language)
+     */
+    useFallbackTranslation(lang) {
+        return (this.config.missingHandler.useFallbackTranslation &&
+            lang !== this.firstFallbackLang);
+    }
+    handleSuccess(lang, translation) {
+        this.setTranslation(translation, lang, { emitChange: false });
+        this.events.next({
+            wasFailure: !!this.failedLangs.size,
+            type: 'translationLoadSuccess',
+            payload: getEventPayload(lang),
+        });
+        this.failedLangs.forEach((l) => this.cache.delete(l));
+        this.failedLangs.clear();
+    }
+    handleFailure(lang, loadOptions) {
+        // When starting to load a first choice language, initialize
+        // the failed counter and resolve the fallback langs.
+        if (isNil(loadOptions.failedCounter)) {
+            loadOptions.failedCounter = 0;
+            if (!loadOptions.fallbackLangs) {
+                loadOptions.fallbackLangs = this.fallbackStrategy.getNextLangs(lang);
+            }
+        }
+        const splitted = lang.split('/');
+        const fallbacks = loadOptions.fallbackLangs;
+        const nextLang = fallbacks[loadOptions.failedCounter];
+        this.failedLangs.add(lang);
+        // This handles the case where a loaded fallback language is requested again
+        if (this.cache.has(nextLang)) {
+            this.handleSuccess(nextLang, this.getTranslation(nextLang));
+            return EMPTY;
+        }
+        const isFallbackLang = nextLang === splitted[splitted.length - 1];
+        if (!nextLang || isFallbackLang) {
+            let msg = `Unable to load translation and all the fallback languages`;
+            if (splitted.length > 1) {
+                msg += `, did you misspelled the scope name?`;
+            }
+            throw new Error(msg);
+        }
+        let resolveLang = nextLang;
+        // if it's scoped lang
+        if (splitted.length > 1) {
+            // We need to resolve it to:
+            // todos/langNotExists => todos/nextLang
+            splitted[splitted.length - 1] = nextLang;
+            resolveLang = splitted.join('/');
+        }
+        loadOptions.failedCounter++;
+        this.events.next({
+            type: 'translationLoadFailure',
+            payload: getEventPayload(lang),
+        });
+        return this.load(resolveLang, loadOptions);
+    }
+    getMappedScope(scope) {
+        const { scopeMapping = {} } = this.config;
+        return scopeMapping[scope] || toCamelCase(scope);
+    }
+    /**
+     * If lang is scope we need to check the following cases:
+     * todos/es => in this case we should take `es` as lang
+     * todos => in this case we should set the active lang as lang
+     */
+    resolveLangAndScope(lang) {
+        let resolveLang = lang;
+        let scope;
+        if (this._isLangScoped(lang)) {
+            // en for example
+            const langFromScope = getLangFromScope(lang);
+            // en is lang
+            const hasLang = this.isLang(langFromScope);
+            // take en
+            resolveLang = hasLang ? langFromScope : this.getActiveLang();
+            // find the scope
+            scope = this.getMappedScope(hasLang ? getScopeFromLang(lang) : lang);
+        }
+        return { scope, resolveLang };
+    }
+    getObjectByKey(translation, key) {
+        const result = {};
+        const prefix = `${key}.`;
+        for (const currentKey in translation) {
+            if (currentKey.startsWith(prefix)) {
+                result[currentKey.replace(prefix, '')] = translation[currentKey];
+            }
+        }
+        return result;
+    }
+    getEntries(key) {
+        return key instanceof Map ? key.entries() : Object.entries(key);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: TranslocoService, deps: [{ token: TRANSLOCO_LOADER, optional: true }, { token: TRANSLOCO_TRANSPILER }, { token: TRANSLOCO_MISSING_HANDLER }, { token: TRANSLOCO_INTERCEPTOR }, { token: TRANSLOCO_CONFIG }, { token: TRANSLOCO_FALLBACK_STRATEGY }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: TranslocoService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: TranslocoService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TRANSLOCO_LOADER]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TRANSLOCO_TRANSPILER]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TRANSLOCO_MISSING_HANDLER]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TRANSLOCO_INTERCEPTOR]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TRANSLOCO_CONFIG]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TRANSLOCO_FALLBACK_STRATEGY]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transloco.service.js","sourceRoot":"","sources":["../../../../../libs/transloco/src/lib/transloco.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, OnDestroy, Optional } from '@angular/core';\nimport {\n  BehaviorSubject,\n  catchError,\n  combineLatest,\n  EMPTY,\n  forkJoin,\n  from,\n  map,\n  Observable,\n  of,\n  retry,\n  shareReplay,\n  Subject,\n  Subscription,\n  switchMap,\n  tap,\n} from 'rxjs';\n\nimport {\n  DefaultLoader,\n  TRANSLOCO_LOADER,\n  TranslocoLoader,\n} from './transloco.loader';\nimport {\n  TRANSLOCO_TRANSPILER,\n  TranslocoTranspiler,\n} from './transloco.transpiler';\nimport {\n  AvailableLangs,\n  HashMap,\n  InlineLoader,\n  LangDefinition,\n  LoadOptions,\n  SetTranslationOptions,\n  TranslateObjectParams,\n  TranslateParams,\n  Translation,\n  TranslocoEvents,\n  TranslocoScope,\n} from './types';\nimport {\n  flatten,\n  isEmpty,\n  isNil,\n  isScopeArray,\n  isScopeObject,\n  isString,\n  size,\n  toCamelCase,\n  unflatten,\n} from './helpers';\nimport { TRANSLOCO_CONFIG, TranslocoConfig } from './transloco.config';\nimport {\n  TRANSLOCO_MISSING_HANDLER,\n  TranslocoMissingHandler,\n  TranslocoMissingHandlerData,\n} from './transloco-missing-handler';\nimport {\n  TRANSLOCO_INTERCEPTOR,\n  TranslocoInterceptor,\n} from './transloco.interceptor';\nimport {\n  TRANSLOCO_FALLBACK_STRATEGY,\n  TranslocoFallbackStrategy,\n} from './transloco-fallback-strategy';\nimport {\n  getEventPayload,\n  getLangFromScope,\n  getScopeFromLang,\n  resolveInlineLoader,\n} from './shared';\nimport { getFallbacksLoaders } from './get-fallbacks-loaders';\nimport { resolveLoader } from './resolve-loader';\n\nlet service: TranslocoService;\n\nexport function translate<T = string>(\n  key: TranslateParams,\n  params: HashMap = {},\n  lang?: string\n): T {\n  return service.translate<T>(key, params, lang);\n}\n\nexport function translateObject<T>(\n  key: TranslateParams,\n  params: HashMap = {},\n  lang?: string\n): T | T[] {\n  return service.translateObject<T>(key, params, lang);\n}\n\n@Injectable({ providedIn: 'root' })\nexport class TranslocoService implements OnDestroy {\n  langChanges$: Observable<string>;\n\n  private subscription: Subscription | null = null;\n  private translations = new Map<string, Translation>();\n  private cache = new Map<string, Observable<Translation>>();\n  private firstFallbackLang: string | undefined;\n  private defaultLang = '';\n  private availableLangs: AvailableLangs = [];\n  private isResolvedMissingOnce = false;\n  private lang: BehaviorSubject<string>;\n  private failedLangs = new Set<string>();\n  private events = new Subject<TranslocoEvents>();\n\n  events$ = this.events.asObservable();\n  readonly config: TranslocoConfig & {\n    scopeMapping?: HashMap<string>;\n  };\n\n  constructor(\n    @Optional() @Inject(TRANSLOCO_LOADER) private loader: TranslocoLoader,\n    @Inject(TRANSLOCO_TRANSPILER) private parser: TranslocoTranspiler,\n    @Inject(TRANSLOCO_MISSING_HANDLER)\n    private missingHandler: TranslocoMissingHandler,\n    @Inject(TRANSLOCO_INTERCEPTOR) private interceptor: TranslocoInterceptor,\n    @Inject(TRANSLOCO_CONFIG) userConfig: TranslocoConfig,\n    @Inject(TRANSLOCO_FALLBACK_STRATEGY)\n    private fallbackStrategy: TranslocoFallbackStrategy\n  ) {\n    if (!this.loader) {\n      this.loader = new DefaultLoader(this.translations);\n    }\n    service = this;\n    this.config = JSON.parse(JSON.stringify(userConfig));\n\n    this.setAvailableLangs(this.config.availableLangs || []);\n    this.setFallbackLangForMissingTranslation(this.config);\n    this.setDefaultLang(this.config.defaultLang);\n    this.lang = new BehaviorSubject<string>(this.getDefaultLang());\n    // Don't use distinctUntilChanged as we need the ability to update\n    // the value when using setTranslation or setTranslationKeys\n    this.langChanges$ = this.lang.asObservable();\n\n    /**\n     * When we have a failure, we want to define the next language that succeeded as the active\n     */\n    this.subscription = this.events$.subscribe((e) => {\n      if (e.type === 'translationLoadSuccess' && e.wasFailure) {\n        this.setActiveLang(e.payload.langName);\n      }\n    });\n  }\n\n  getDefaultLang() {\n    return this.defaultLang;\n  }\n\n  setDefaultLang(lang: string) {\n    this.defaultLang = lang;\n  }\n\n  getActiveLang() {\n    return this.lang.getValue();\n  }\n\n  setActiveLang(lang: string) {\n    this.parser.onLangChanged?.(lang);\n    this.lang.next(lang);\n    this.events.next({\n      type: 'langChanged',\n      payload: getEventPayload(lang),\n    });\n    return this;\n  }\n\n  setAvailableLangs(langs: AvailableLangs) {\n    this.availableLangs = langs;\n  }\n\n  /**\n   * Gets the available languages.\n   *\n   * @returns\n   * An array of the available languages. Can be either a `string[]` or a `{ id: string; label: string }[]`\n   * depending on how the available languages are set in your module.\n   */\n  getAvailableLangs() {\n    return this.availableLangs;\n  }\n\n  load(path: string, options: LoadOptions = {}): Observable<Translation> {\n    const cached = this.cache.get(path);\n    if (cached) {\n      return cached;\n    }\n\n    let loadTranslation: Observable<\n      Translation | { translation: Translation; lang: string }[]\n    >;\n    const isScope = this._isLangScoped(path);\n    let scope: string;\n    if (isScope) {\n      scope = getScopeFromLang(path);\n    }\n\n    const loadersOptions = {\n      path,\n      mainLoader: this.loader,\n      inlineLoader: options.inlineLoader,\n      data: isScope ? { scope: scope! } : undefined,\n    };\n\n    if (this.useFallbackTranslation(path)) {\n      // if the path is scope the fallback should be `scope/fallbackLang`;\n      const fallback = isScope\n        ? `${scope!}/${this.firstFallbackLang}`\n        : this.firstFallbackLang;\n\n      const loaders = getFallbacksLoaders({\n        ...loadersOptions,\n        fallbackPath: fallback!,\n      });\n      loadTranslation = forkJoin(loaders);\n    } else {\n      const loader = resolveLoader(loadersOptions);\n      loadTranslation = from(loader);\n    }\n\n    const load$ = loadTranslation.pipe(\n      retry(this.config.failedRetries),\n      tap((translation) => {\n        if (Array.isArray(translation)) {\n          translation.forEach((t) => {\n            this.handleSuccess(t.lang, t.translation);\n            // Save the fallback in cache so we'll not create a redundant request\n            if (t.lang !== path) {\n              this.cache.set(t.lang, of({}));\n            }\n          });\n          return;\n        }\n        this.handleSuccess(path, translation);\n      }),\n      catchError((error) => {\n        if (!this.config.prodMode) {\n          console.error(`Error while trying to load \"${path}\"`, error);\n        }\n\n        return this.handleFailure(path, options);\n      }),\n      shareReplay(1)\n    );\n\n    this.cache.set(path, load$);\n\n    return load$;\n  }\n\n  /**\n   * Gets the instant translated value of a key\n   *\n   * @example\n   *\n   * translate<string>('hello')\n   * translate('hello', { value: 'value' })\n   * translate<string[]>(['hello', 'key'])\n   * translate('hello', { }, 'en')\n   * translate('scope.someKey', { }, 'en')\n   */\n  translate<T = string>(\n    key: TranslateParams,\n    params: HashMap = {},\n    lang = this.getActiveLang()\n  ): T {\n    if (!key) return key as any;\n\n    const { scope, resolveLang } = this.resolveLangAndScope(lang);\n\n    if (Array.isArray(key)) {\n      return key.map((k) =>\n        this.translate(scope ? `${scope}.${k}` : k, params, resolveLang)\n      ) as any;\n    }\n\n    key = scope ? `${scope}.${key}` : key;\n\n    const translation = this.getTranslation(resolveLang);\n    const value = translation[key];\n\n    if (!value) {\n      return this._handleMissingKey(key, value, params);\n    }\n\n    return this.parser.transpile({\n      value, params, translation, key\n    });\n  }\n\n  /**\n   * Gets the translated value of a key as observable\n   *\n   * @example\n   *\n   * selectTranslate<string>('hello').subscribe(value => ...)\n   * selectTranslate<string>('hello', {}, 'es').subscribe(value => ...)\n   * selectTranslate<string>('hello', {}, 'todos').subscribe(value => ...)\n   * selectTranslate<string>('hello', {}, { scope: 'todos' }).subscribe(value => ...)\n   *\n   */\n  selectTranslate<T = any>(\n    key: TranslateParams,\n    params?: HashMap,\n    lang?: string | TranslocoScope | TranslocoScope[],\n    _isObject = false\n  ): Observable<T> {\n    let inlineLoader: InlineLoader | undefined;\n    const load = (lang: string, options?: LoadOptions) =>\n      this.load(lang, options).pipe(\n        map(() =>\n          _isObject\n            ? this.translateObject(key, params, lang)\n            : this.translate(key, params, lang)\n        )\n      );\n    if (isNil(lang)) {\n      return this.langChanges$.pipe(switchMap((lang) => load(lang)));\n    }\n\n    if (isScopeArray(lang) || isScopeObject(lang)) {\n      // it's a scope object.\n      const providerScope = Array.isArray(lang) ? lang[0] : lang;\n      lang = providerScope.scope;\n      inlineLoader = resolveInlineLoader(providerScope, providerScope.scope);\n    }\n\n    lang = lang as string;\n    if (this.isLang(lang) || this.isScopeWithLang(lang)) {\n      return load(lang);\n    }\n    // it's a scope\n    const scope = lang;\n    return this.langChanges$.pipe(\n      switchMap((lang) => load(`${scope}/${lang}`, { inlineLoader }))\n    );\n  }\n\n  /**\n   * Whether the scope with lang\n   *\n   * @example\n   *\n   * todos/en => true\n   * todos => false\n   */\n  private isScopeWithLang(lang: string) {\n    return this.isLang(getLangFromScope(lang));\n  }\n\n  /**\n   * Translate the given path that returns an object\n   *\n   * @example\n   *\n   * service.translateObject('path.to.object', {'subpath': { value: 'someValue'}}) => returns translated object\n   *\n   */\n  translateObject<T = any>(key: string, params?: HashMap, lang?: string): T;\n  translateObject<T = any>(key: string[], params?: HashMap, lang?: string): T[];\n  translateObject<T = any>(\n    key: TranslateParams,\n    params?: HashMap,\n    lang?: string\n  ): T | T[];\n  translateObject<T = any>(\n    key: HashMap | Map<string, HashMap>,\n    params?: null,\n    lang?: string\n  ): T[];\n  translateObject<T = any>(\n    key: TranslateObjectParams,\n    params: HashMap | null = {},\n    lang = this.getActiveLang()\n  ): T | T[] {\n    if (isString(key) || Array.isArray(key)) {\n      const { resolveLang, scope } = this.resolveLangAndScope(lang);\n      if (Array.isArray(key)) {\n        return key.map((k) =>\n          this.translateObject(\n            scope ? `${scope}.${k}` : k,\n            params!,\n            resolveLang\n          )\n        ) as any;\n      }\n\n      const translation = this.getTranslation(resolveLang);\n      key = scope ? `${scope}.${key}` : key;\n\n      const value = unflatten(this.getObjectByKey(translation, key));\n      /* If an empty object was returned we want to try and translate the key as a string and not an object */\n      return isEmpty(value)\n        ? this.translate(key, params!, lang)\n        : this.parser.transpile({value, params: params!, translation, key});\n    }\n\n    const translations: T[] = [];\n    for (const [_key, _params] of this.getEntries(key)) {\n      translations.push(this.translateObject(_key, _params, lang));\n    }\n\n    return translations;\n  }\n\n  selectTranslateObject<T = any>(\n    key: string,\n    params?: HashMap,\n    lang?: string\n  ): Observable<T>;\n  selectTranslateObject<T = any>(\n    key: string[],\n    params?: HashMap,\n    lang?: string\n  ): Observable<T[]>;\n  selectTranslateObject<T = any>(\n    key: TranslateParams,\n    params?: HashMap,\n    lang?: string\n  ): Observable<T> | Observable<T[]>;\n  selectTranslateObject<T = any>(\n    key: HashMap | Map<string, HashMap>,\n    params?: null,\n    lang?: string\n  ): Observable<T[]>;\n  selectTranslateObject<T = any>(\n    key: TranslateObjectParams,\n    params?: HashMap | null,\n    lang?: string\n  ): Observable<T> | Observable<T[]> {\n    if (isString(key) || Array.isArray(key)) {\n      return this.selectTranslate<T>(key, params!, lang, true);\n    }\n\n    const [[firstKey, firstParams], ...rest] = this.getEntries(key);\n\n    /* In order to avoid subscribing multiple times to the load language event by calling selectTranslateObject for each pair,\n     * we listen to when the first key has been translated (the language is loaded) and translate the rest synchronously */\n    return this.selectTranslateObject<T>(firstKey, firstParams, lang).pipe(\n      map((value) => {\n        const translations = [value];\n        for (const [_key, _params] of rest) {\n          translations.push(this.translateObject<T>(_key, _params, lang));\n        }\n\n        return translations;\n      })\n    );\n  }\n\n  /**\n   * Gets an object of translations for a given language\n   *\n   * @example\n   *\n   * getTranslation()\n   * getTranslation('en')\n   * getTranslation('admin-page/en')\n   */\n  getTranslation(): Map<string, Translation>;\n  getTranslation(langOrScope: string): Translation;\n  getTranslation(langOrScope?: string): Map<string, Translation> | Translation {\n    if (langOrScope) {\n      if (this.isLang(langOrScope)) {\n        return this.translations.get(langOrScope) || {};\n      } else {\n        // This is a scope, build the scope value from the translation object\n        const { scope, resolveLang } = this.resolveLangAndScope(langOrScope);\n        const translation = this.translations.get(resolveLang) || {};\n\n        return this.getObjectByKey(translation, scope);\n      }\n    }\n\n    return this.translations;\n  }\n\n  /**\n   * Gets an object of translations for a given language\n   *\n   * @example\n   *\n   * selectTranslation().subscribe() - will return the current lang translation\n   * selectTranslation('es').subscribe()\n   * selectTranslation('admin-page').subscribe() - will return the current lang scope translation\n   * selectTranslation('admin-page/es').subscribe()\n   */\n  selectTranslation(lang?: string): Observable<Translation> {\n    let language$ = this.langChanges$;\n    if (lang) {\n      const scopeLangSpecified = getLangFromScope(lang) !== lang;\n      if (this.isLang(lang) || scopeLangSpecified) {\n        language$ = of(lang);\n      } else {\n        language$ = this.langChanges$.pipe(\n          map((currentLang) => `${lang}/${currentLang}`)\n        );\n      }\n    }\n\n    return language$.pipe(\n      switchMap((language) =>\n        this.load(language).pipe(map(() => this.getTranslation(language)))\n      )\n    );\n  }\n\n  /**\n   * Sets or merge a given translation object to current lang\n   *\n   * @example\n   *\n   * setTranslation({ ... })\n   * setTranslation({ ... }, 'en')\n   * setTranslation({ ... }, 'es', { merge: false } )\n   * setTranslation({ ... }, 'todos/en', { merge: false } )\n   */\n  setTranslation(\n    translation: Translation,\n    lang = this.getActiveLang(),\n    options: SetTranslationOptions = {}\n  ) {\n    const defaults = { merge: true, emitChange: true };\n    const mergedOptions = { ...defaults, ...options };\n    const scope = getScopeFromLang(lang);\n\n    /**\n     * If this isn't a scope we use the whole translation as is\n     * otherwise we need to flat the scope and use it\n     */\n    let flattenScopeOrTranslation = translation;\n\n    // Merged the scoped language into the active language\n    if (scope) {\n      const key = this.getMappedScope(scope);\n      flattenScopeOrTranslation = flatten({ [key]: translation });\n    }\n\n    const currentLang = scope ? getLangFromScope(lang) : lang;\n\n    const mergedTranslation = {\n      ...(mergedOptions.merge && this.getTranslation(currentLang)),\n      ...flattenScopeOrTranslation,\n    };\n\n    const flattenTranslation = this.config.flatten!.aot\n      ? mergedTranslation\n      : flatten(mergedTranslation);\n    const withHook = this.interceptor.preSaveTranslation(\n      flattenTranslation,\n      currentLang\n    );\n    this.translations.set(currentLang, withHook);\n    mergedOptions.emitChange && this.setActiveLang(this.getActiveLang());\n  }\n\n  /**\n   * Sets translation key with given value\n   *\n   * @example\n   *\n   * setTranslationKey('key', 'value')\n   * setTranslationKey('key.nested', 'value')\n   * setTranslationKey('key.nested', 'value', 'en')\n   * setTranslationKey('key.nested', 'value', 'en', { emitChange: false } )\n   */\n  setTranslationKey(\n    key: string,\n    value: string,\n    options: Omit<SetTranslationOptions, 'merge'> = {}\n  ) {\n    const lang = options.lang || this.getActiveLang();\n    const withHook = this.interceptor.preSaveTranslationKey(key, value, lang);\n    const newValue = {\n      [key]: withHook,\n    };\n\n    this.setTranslation(newValue, lang, { ...options, merge: true });\n  }\n\n  /**\n   * Sets the fallback lang for the currently active language\n   * @param fallbackLang\n   */\n  setFallbackLangForMissingTranslation({\n    fallbackLang,\n  }: Pick<TranslocoConfig, 'fallbackLang'>) {\n    const lang = Array.isArray(fallbackLang) ? fallbackLang[0] : fallbackLang;\n    if (fallbackLang && this.useFallbackTranslation(lang)) {\n      this.firstFallbackLang = lang!;\n    }\n  }\n\n  /**\n   * @internal\n   */\n  _handleMissingKey(key: string, value: any, params?: HashMap) {\n    if (this.config.missingHandler!.allowEmpty && value === '') {\n      return '';\n    }\n\n    if (!this.isResolvedMissingOnce && this.useFallbackTranslation()) {\n      // We need to set it to true to prevent a loop\n      this.isResolvedMissingOnce = true;\n      const fallbackValue = this.translate(\n        key,\n        params,\n        this.firstFallbackLang!\n      );\n      this.isResolvedMissingOnce = false;\n\n      return fallbackValue;\n    }\n\n    return this.missingHandler.handle(\n      key,\n      this.getMissingHandlerData(),\n      params\n    );\n  }\n\n  /**\n   * @internal\n   */\n  _isLangScoped(lang: string) {\n    return this.getAvailableLangsIds().indexOf(lang) === -1;\n  }\n\n  /**\n   * Checks if a given string is one of the specified available languages.\n   * @returns\n   * True if the given string is an available language.\n   * False if the given string is not an available language.\n   */\n  isLang(lang: string): boolean {\n    return this.getAvailableLangsIds().indexOf(lang) !== -1;\n  }\n\n  /**\n   * @internal\n   *\n   * We always want to make sure the global lang is loaded\n   * before loading the scope since you can access both via the pipe/directive.\n   */\n  _loadDependencies(\n    path: string,\n    inlineLoader?: InlineLoader\n  ): Observable<Translation | Translation[]> {\n    const mainLang = getLangFromScope(path);\n\n    if (this._isLangScoped(path) && !this.isLoadedTranslation(mainLang)) {\n      return combineLatest([\n        this.load(mainLang),\n        this.load(path, { inlineLoader }),\n      ]);\n    }\n    return this.load(path, { inlineLoader });\n  }\n\n  /**\n   * @internal\n   */\n  _completeScopeWithLang(langOrScope: string) {\n    if (\n      this._isLangScoped(langOrScope) &&\n      !this.isLang(getLangFromScope(langOrScope))\n    ) {\n      return `${langOrScope}/${this.getActiveLang()}`;\n    }\n    return langOrScope;\n  }\n\n  /**\n   * @internal\n   */\n  _setScopeAlias(scope: string, alias: string) {\n    if (!this.config.scopeMapping) {\n      this.config.scopeMapping = {};\n    }\n    this.config.scopeMapping[scope] = alias;\n  }\n\n  ngOnDestroy() {\n    if (this.subscription) {\n      this.subscription.unsubscribe();\n      // Caretaker note: it's important to clean up references to subscriptions since they save the `next`\n      // callback within its `destination` property, preventing classes from being GC'd.\n      this.subscription = null;\n    }\n    // Caretaker note: since this is the root provider, it'll be destroyed when the `NgModuleRef.destroy()` is run.\n    // Cached values capture `this`, thus leading to a circular reference and preventing the `TranslocoService` from\n    // being GC'd. This would lead to a memory leak when server-side rendering is used since the service is created\n    // and destroyed per each HTTP request, but any service is not getting GC'd.\n    this.cache.clear();\n  }\n\n  private isLoadedTranslation(lang: string) {\n    return size(this.getTranslation(lang));\n  }\n\n  private getAvailableLangsIds(): string[] {\n    const first = this.getAvailableLangs()[0];\n\n    if (isString(first)) {\n      return this.getAvailableLangs() as string[];\n    }\n\n    return (this.getAvailableLangs() as LangDefinition[]).map((l) => l.id);\n  }\n\n  private getMissingHandlerData(): TranslocoMissingHandlerData {\n    return {\n      ...this.config,\n      activeLang: this.getActiveLang(),\n      availableLangs: this.availableLangs,\n      defaultLang: this.defaultLang,\n    };\n  }\n\n  /**\n   * Use a fallback translation set for missing keys of the primary language\n   * This is unrelated to the fallback language (which changes the active language)\n   */\n  private useFallbackTranslation(lang?: string) {\n    return (\n      this.config.missingHandler!.useFallbackTranslation &&\n      lang !== this.firstFallbackLang\n    );\n  }\n\n  private handleSuccess(lang: string, translation: Translation) {\n    this.setTranslation(translation, lang, { emitChange: false });\n    this.events.next({\n      wasFailure: !!this.failedLangs.size,\n      type: 'translationLoadSuccess',\n      payload: getEventPayload(lang),\n    });\n    this.failedLangs.forEach((l) => this.cache.delete(l));\n    this.failedLangs.clear();\n  }\n\n  private handleFailure(lang: string, loadOptions: LoadOptions) {\n    // When starting to load a first choice language, initialize\n    // the failed counter and resolve the fallback langs.\n    if (isNil(loadOptions.failedCounter)) {\n      loadOptions.failedCounter = 0;\n\n      if (!loadOptions.fallbackLangs) {\n        loadOptions.fallbackLangs = this.fallbackStrategy.getNextLangs(lang);\n      }\n    }\n\n    const splitted = lang.split('/');\n    const fallbacks = loadOptions.fallbackLangs;\n    const nextLang = fallbacks![loadOptions.failedCounter!];\n    this.failedLangs.add(lang);\n\n    // This handles the case where a loaded fallback language is requested again\n    if (this.cache.has(nextLang)) {\n      this.handleSuccess(nextLang, this.getTranslation(nextLang));\n      return EMPTY;\n    }\n\n    const isFallbackLang = nextLang === splitted[splitted.length - 1];\n\n    if (!nextLang || isFallbackLang) {\n      let msg = `Unable to load translation and all the fallback languages`;\n      if (splitted.length > 1) {\n        msg += `, did you misspelled the scope name?`;\n      }\n\n      throw new Error(msg);\n    }\n\n    let resolveLang = nextLang;\n    // if it's scoped lang\n    if (splitted.length > 1) {\n      // We need to resolve it to:\n      // todos/langNotExists => todos/nextLang\n      splitted[splitted.length - 1] = nextLang;\n      resolveLang = splitted.join('/');\n    }\n\n    loadOptions.failedCounter!++;\n    this.events.next({\n      type: 'translationLoadFailure',\n      payload: getEventPayload(lang),\n    });\n\n    return this.load(resolveLang, loadOptions);\n  }\n\n  private getMappedScope(scope: string): string {\n    const { scopeMapping = {} } = this.config;\n    return scopeMapping[scope] || toCamelCase(scope);\n  }\n\n  /**\n   * If lang is scope we need to check the following cases:\n   * todos/es => in this case we should take `es` as lang\n   * todos => in this case we should set the active lang as lang\n   */\n  private resolveLangAndScope(lang: string) {\n    let resolveLang = lang;\n    let scope;\n\n    if (this._isLangScoped(lang)) {\n      // en for example\n      const langFromScope = getLangFromScope(lang);\n      // en is lang\n      const hasLang = this.isLang(langFromScope);\n      // take en\n      resolveLang = hasLang ? langFromScope : this.getActiveLang();\n      // find the scope\n      scope = this.getMappedScope(hasLang ? getScopeFromLang(lang) : lang);\n    }\n\n    return { scope, resolveLang };\n  }\n\n  private getObjectByKey(translation: Translation, key?: string) {\n    const result: Translation = {};\n    const prefix = `${key}.`;\n\n    for (const currentKey in translation) {\n      if (currentKey.startsWith(prefix)) {\n        result[currentKey.replace(prefix, '')] = translation[currentKey];\n      }\n    }\n\n    return result;\n  }\n\n  private getEntries(key: HashMap | Map<string, HashMap>) {\n    return key instanceof Map ? key.entries() : Object.entries(key);\n  }\n}\n"]}