@ngneat/transloco/esm2015/lib/transloco.service.js

The internationalization (i18n) library for Angular

/**
 * @fileoverview added by tsickle
 * Generated from: lib/transloco.service.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
import { Inject, Injectable, Optional } from '@angular/core';
import { BehaviorSubject, combineLatest, EMPTY, forkJoin, from, of, Subject } from 'rxjs';
import { catchError, map, retry, shareReplay, switchMap, tap } from 'rxjs/operators';
import { DefaultLoader, TRANSLOCO_LOADER } from './transloco.loader';
import { TRANSLOCO_TRANSPILER } from './transloco.transpiler';
import { flatten, isEmpty, isNil, isScopeObject, isString, size, toCamelCase, unflatten } from './helpers';
import { defaultConfig, 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 { mergeConfig } from './merge-config';
import { getEventPayload, getLangFromScope, getScopeFromLang, resolveInlineLoader } from './shared';
import { getFallbacksLoaders } from './get-fallbacks-loaders';
import { resolveLoader } from './resolve-loader';
import * as i0 from "@angular/core";
import * as i1 from "./transloco.loader";
import * as i2 from "./transloco.transpiler";
import * as i3 from "./transloco-missing-handler";
import * as i4 from "./transloco.interceptor";
import * as i5 from "./transloco.config";
import * as i6 from "./transloco-fallback-strategy";
/** @type {?} */
let service;
/**
 * @template T
 * @param {?} key
 * @param {?=} params
 * @param {?=} lang
 * @return {?}
 */
export function translate(key, params = {}, lang) {
    return service.translate(key, params, lang);
}
export class TranslocoService {
    /**
     * @param {?} loader
     * @param {?} parser
     * @param {?} missingHandler
     * @param {?} interceptor
     * @param {?} userConfig
     * @param {?} fallbackStrategy
     */
    constructor(loader, parser, missingHandler, interceptor, userConfig, fallbackStrategy) {
        this.loader = loader;
        this.parser = parser;
        this.missingHandler = missingHandler;
        this.interceptor = interceptor;
        this.userConfig = userConfig;
        this.fallbackStrategy = fallbackStrategy;
        this.translations = new Map();
        this.cache = new Map();
        this.firstFallbackLang = null;
        this.availableLangs = [];
        this.isResolvedMissingOnce = false;
        this.events = new Subject();
        this.events$ = this.events.asObservable();
        this.failedLangs = new Set();
        if (!this.loader) {
            this.loader = new DefaultLoader(this.translations);
        }
        service = this;
        this.mergedConfig = mergeConfig(defaultConfig, userConfig);
        this.setAvailableLangs(this.mergedConfig.availableLangs);
        this.setFallbackLangForMissingTranslation(this.mergedConfig);
        this.setDefaultLang(this.mergedConfig.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((/**
         * @param {?} e
         * @return {?}
         */
        e => {
            if (e.type === 'translationLoadSuccess' && e.wasFailure) {
                // Handle scoped lang
                /** @type {?} */
                const lang = getLangFromScope(e.payload.lang);
                this.setActiveLang(lang);
            }
        }));
    }
    /**
     * @return {?}
     */
    get config() {
        return this.mergedConfig;
    }
    /**
     * @return {?}
     */
    getDefaultLang() {
        return this.defaultLang;
    }
    /**
     * @param {?} lang
     * @return {?}
     */
    setDefaultLang(lang) {
        this.defaultLang = lang;
    }
    /**
     * @return {?}
     */
    getActiveLang() {
        return this.lang.getValue();
    }
    /**
     * @template THIS
     * @this {THIS}
     * @param {?} lang
     * @return {THIS}
     */
    setActiveLang(lang) {
        (/** @type {?} */ (this)).parser.onLangChanged && (/** @type {?} */ (this)).parser.onLangChanged(lang);
        (/** @type {?} */ (this)).lang.next(lang);
        return (/** @type {?} */ (this));
    }
    /**
     * @param {?} langs
     * @return {?}
     */
    setAvailableLangs(langs) {
        this.availableLangs = langs;
    }
    /**
     * Gets the available languages.
     *
     * @return {?}
     * 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;
    }
    /**
     * @param {?} path
     * @param {?=} options
     * @return {?}
     */
    load(path, options = {}) {
        if (this.cache.has(path) === false) {
            /** @type {?} */
            let loadTranslation;
            /** @type {?} */
            const isScope = this._isLangScoped(path);
            /** @type {?} */
            const scope = isScope ? getScopeFromLang(path) : null;
            if (this.useFallbackTranslation(path)) {
                // if the path is scope the fallback should be `scope/fallbackLang`;
                /** @type {?} */
                const fallback = isScope ? `${scope}/${this.firstFallbackLang}` : this.firstFallbackLang;
                /** @type {?} */
                const loaders = getFallbacksLoaders(path, fallback, this.loader, options.inlineLoader, { scope });
                loadTranslation = forkJoin(loaders);
            }
            else {
                /** @type {?} */
                const loader = resolveLoader(path, this.loader, options.inlineLoader, { scope });
                loadTranslation = from(loader);
            }
            /** @type {?} */
            const load$ = loadTranslation.pipe(retry(this.config.failedRetries), tap((/**
             * @param {?} translation
             * @return {?}
             */
            translation => {
                if (Array.isArray(translation)) {
                    translation.forEach((/**
                     * @param {?} t
                     * @return {?}
                     */
                    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((/**
             * @return {?}
             */
            () => this.handleFailure(path, options))), shareReplay(1));
            this.cache.set(path, load$);
        }
        return this.cache.get(path);
    }
    /**
     * 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')
     * @template T
     * @param {?} key
     * @param {?=} params
     * @param {?=} lang
     * @return {?}
     */
    translate(key, params = {}, lang = this.getActiveLang()) {
        if (!key)
            return (/** @type {?} */ (key));
        const { scope, resolveLang } = this.resolveLangAndScope(lang);
        if (Array.isArray(key)) {
            return (/** @type {?} */ (key.map((/**
             * @param {?} k
             * @return {?}
             */
            k => this.translate(scope ? `${scope}.${k}` : k, params, resolveLang)))));
        }
        key = scope ? `${scope}.${key}` : key;
        /** @type {?} */
        const translation = this.getTranslation(resolveLang);
        /** @type {?} */
        const value = translation[key];
        if (!value) {
            return this._handleMissingKey(key, value, params);
        }
        return this.parser.transpile(value, params, translation);
    }
    /**
     * 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 => ...)
     *
     * @template T
     * @param {?} key
     * @param {?=} params
     * @param {?=} lang
     * @param {?=} _isObject
     * @return {?}
     */
    selectTranslate(key, params, lang, _isObject = false) {
        /** @type {?} */
        let inlineLoader = null;
        /** @type {?} */
        const load = (/**
         * @param {?} lang
         * @param {?=} options
         * @return {?}
         */
        (lang, options) => this.load(lang, options).pipe(map((/**
         * @return {?}
         */
        () => (_isObject ? this.translateObject(key, params, lang) : this.translate(key, params, lang))))));
        if (isNil(lang)) {
            return this.langChanges$.pipe(switchMap((/**
             * @param {?} lang
             * @return {?}
             */
            lang => load(lang))));
        }
        if (isScopeObject(lang)) {
            // it's a scope object.
            /** @type {?} */
            const providerScope = (/** @type {?} */ (lang));
            lang = providerScope.scope;
            inlineLoader = resolveInlineLoader(providerScope, providerScope.scope);
        }
        lang = (/** @type {?} */ (lang));
        if (this.isLang(lang) || this.isScopeWithLang(lang)) {
            return load(lang);
        }
        // it's a scope
        /** @type {?} */
        const scope = lang;
        return this.langChanges$.pipe(switchMap((/**
         * @param {?} lang
         * @return {?}
         */
        lang => load(`${scope}/${lang}`, { inlineLoader }))));
    }
    /**
     * Whether the scope with lang
     *
     * \@example
     *
     * todos/en => true
     * todos => false
     * @private
     * @param {?} lang
     * @return {?}
     */
    isScopeWithLang(lang) {
        return this.isLang(getLangFromScope(lang));
    }
    /**
     * @template T
     * @param {?} key
     * @param {?=} params
     * @param {?=} lang
     * @return {?}
     */
    translateObject(key, params, lang = this.getActiveLang()) {
        if (isString(key) || Array.isArray(key)) {
            if (Array.isArray(key)) {
                return (/** @type {?} */ (key.map((/**
                 * @param {?} k
                 * @return {?}
                 */
                k => this.translateObject(scope ? `${scope}.${k}` : k, params, resolveLang)))));
            }
            const { resolveLang, scope } = this.resolveLangAndScope(lang);
            /** @type {?} */
            const translation = this.getTranslation(resolveLang);
            key = scope ? `${scope}.${key}` : key;
            /** @type {?} */
            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, translation);
        }
        /** @type {?} */
        const translations = [];
        for (const [_key, _params] of this.getEntries(key)) {
            translations.push(this.translateObject(_key, _params, lang));
        }
        return translations;
    }
    /**
     * @template T
     * @param {?} key
     * @param {?=} params
     * @param {?=} lang
     * @return {?}
     */
    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((/**
         * @param {?} value
         * @return {?}
         */
        value => {
            /** @type {?} */
            const translations = [value];
            for (const [_key, _params] of rest) {
                translations.push(this.translateObject(_key, _params, lang));
            }
            return translations;
        })));
    }
    /**
     * @param {?=} langOrScope
     * @return {?}
     */
    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);
                /** @type {?} */
                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()
     * @param {?=} lang
     * @return {?}
     */
    selectTranslation(lang) {
        /** @type {?} */
        let language$ = this.langChanges$;
        if (lang) {
            /** @type {?} */
            const scopeLangSpecified = getLangFromScope(lang) !== lang;
            if (this.isLang(lang) || scopeLangSpecified) {
                language$ = of(lang);
            }
            else {
                language$ = this.langChanges$.pipe(map((/**
                 * @param {?} currentLang
                 * @return {?}
                 */
                currentLang => `${lang}/${currentLang}`)));
            }
        }
        return language$.pipe(switchMap((/**
         * @param {?} language
         * @return {?}
         */
        language => this.load(language).pipe(map((/**
         * @return {?}
         */
        () => 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 } )
     * @param {?} translation
     * @param {?=} lang
     * @param {?=} options
     * @return {?}
     */
    setTranslation(translation, lang = this.getActiveLang(), options = {}) {
        /** @type {?} */
        const defaults = { merge: true, emitChange: true };
        /** @type {?} */
        const mergedOptions = Object.assign({}, defaults, options);
        /** @type {?} */
        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
         * @type {?}
         */
        let flattenScopeOrTranslation = translation;
        // Merged the scoped language into the active language
        if (scope) {
            /** @type {?} */
            const key = this.getMappedScope(scope);
            flattenScopeOrTranslation = flatten({ [key]: translation });
        }
        /** @type {?} */
        const currentLang = scope ? getLangFromScope(lang) : lang;
        /** @type {?} */
        const mergedTranslation = Object.assign({}, (mergedOptions.merge && this.getTranslation(currentLang)), flattenScopeOrTranslation);
        /** @type {?} */
        const flattenTranslation = this.mergedConfig.flatten.aot ? mergedTranslation : flatten(mergedTranslation);
        /** @type {?} */
        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 } )
     * @param {?} key
     * @param {?} value
     * @param {?=} lang
     * @param {?=} options
     * @return {?}
     */
    setTranslationKey(key, value, lang = this.getActiveLang(), 
    // Todo: Use Omit and merge options and lang to one object in v3
    options = {}) {
        /** @type {?} */
        const withHook = this.interceptor.preSaveTranslationKey(key, value, lang);
        /** @type {?} */
        const newValue = {
            [key]: withHook
        };
        this.setTranslation(newValue, lang, Object.assign({}, options, { merge: true }));
    }
    /**
     * Sets the fallback lang for the currently active language
     * @param {?} __0
     * @return {?}
     */
    setFallbackLangForMissingTranslation({ fallbackLang }) {
        /** @type {?} */
        const lang = Array.isArray(fallbackLang) ? fallbackLang[0] : fallbackLang;
        if (this.useFallbackTranslation(lang) && fallbackLang) {
            this.firstFallbackLang = lang;
        }
    }
    /**
     * \@internal
     * @param {?} key
     * @param {?} value
     * @param {?=} params
     * @return {?}
     */
    _handleMissingKey(key, value, params) {
        if (this.config.missingHandler.allowEmpty && value === '') {
            return '';
        }
        if (this.useFallbackTranslation() && !this.isResolvedMissingOnce) {
            // We need to set it to true to prevent a loop
            this.isResolvedMissingOnce = true;
            /** @type {?} */
            const fallbackValue = this.translate(key, params, this.firstFallbackLang);
            this.isResolvedMissingOnce = false;
            return fallbackValue;
        }
        return this.missingHandler.handle(key, this.getMissingHandlerData(), params);
    }
    /**
     * \@internal
     * @param {?} lang
     * @return {?}
     */
    _isLangScoped(lang) {
        return this.getAvailableLangsIds().indexOf(lang) === -1;
    }
    /**
     * Checks if a given string is one of the specified available languages.
     * @param {?} lang
     * @return {?}
     * 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.
     * @param {?} path
     * @param {?=} inlineLoader
     * @return {?}
     */
    _loadDependencies(path, inlineLoader) {
        /** @type {?} */
        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
     * @param {?} langOrScope
     * @return {?}
     */
    _completeScopeWithLang(langOrScope) {
        if (this._isLangScoped(langOrScope) && !this.isLang(getLangFromScope(langOrScope))) {
            return `${langOrScope}/${this.getActiveLang()}`;
        }
        return langOrScope;
    }
    /**
     * \@internal
     * @param {?} scope
     * @param {?} alias
     * @return {?}
     */
    _setScopeAlias(scope, alias) {
        if (!this.mergedConfig.scopeMapping) {
            this.mergedConfig.scopeMapping = {};
        }
        this.mergedConfig.scopeMapping[scope] = alias;
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        this.subscription.unsubscribe();
        // 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();
    }
    /**
     * @private
     * @param {?} lang
     * @return {?}
     */
    isLoadedTranslation(lang) {
        return size(this.getTranslation(lang));
    }
    /**
     * @private
     * @return {?}
     */
    getAvailableLangsIds() {
        /** @type {?} */
        const first = this.getAvailableLangs()[0];
        if (isString(first)) {
            return (/** @type {?} */ (this.getAvailableLangs()));
        }
        return ((/** @type {?} */ (this.getAvailableLangs()))).map((/**
         * @param {?} l
         * @return {?}
         */
        l => l.id));
    }
    /**
     * @private
     * @return {?}
     */
    getMissingHandlerData() {
        return Object.assign({}, 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)
     * @private
     * @param {?=} lang
     * @return {?}
     */
    useFallbackTranslation(lang) {
        return this.config.missingHandler.useFallbackTranslation && lang !== this.firstFallbackLang;
    }
    /**
     * @private
     * @param {?} lang
     * @param {?} translation
     * @return {?}
     */
    handleSuccess(lang, translation) {
        this.setTranslation(translation, lang, { emitChange: false });
        this.events.next({
            wasFailure: !!this.failedLangs.size,
            type: 'translationLoadSuccess',
            payload: getEventPayload(lang)
        });
        this.failedLangs.forEach((/**
         * @param {?} l
         * @return {?}
         */
        l => this.cache.delete(l)));
        this.failedLangs.clear();
    }
    /**
     * @private
     * @param {?} lang
     * @param {?} loadOptions
     * @return {?}
     */
    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);
            }
        }
        /** @type {?} */
        const splitted = lang.split('/');
        /** @type {?} */
        const fallbacks = loadOptions.fallbackLangs;
        /** @type {?} */
        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;
        }
        /** @type {?} */
        const isFallbackLang = nextLang === splitted[splitted.length - 1];
        if (!nextLang || isFallbackLang) {
            /** @type {?} */
            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);
        }
        /** @type {?} */
        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);
    }
    /**
     * @private
     * @param {?} scope
     * @return {?}
     */
    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
     * @private
     * @param {?} lang
     * @return {?}
     */
    resolveLangAndScope(lang) {
        /** @type {?} */
        let resolveLang = lang;
        /** @type {?} */
        let scope;
        if (this._isLangScoped(lang)) {
            // en for example
            /** @type {?} */
            const langFromScope = getLangFromScope(lang);
            // en is lang
            /** @type {?} */
            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 };
    }
    /**
     * @private
     * @param {?} translation
     * @param {?} key
     * @return {?}
     */
    getObjectByKey(translation, key) {
        /** @type {?} */
        const result = {};
        /** @type {?} */
        const prefix = `${key}.`;
        for (const currentKey in translation) {
            if (currentKey.startsWith(prefix)) {
                result[currentKey.replace(prefix, '')] = translation[currentKey];
            }
        }
        return result;
    }
    /**
     * @private
     * @param {?} key
     * @return {?}
     */
    getEntries(key) {
        return key instanceof Map ? key.entries() : Object.entries(key);
    }
}
TranslocoService.decorators = [
    { type: Injectable, args: [{ providedIn: 'root' },] }
];
/** @nocollapse */
TranslocoService.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,] }] }
];
/** @nocollapse */ TranslocoService.ngInjectableDef = i0.defineInjectable({ factory: function TranslocoService_Factory() { return new TranslocoService(i0.inject(i1.TRANSLOCO_LOADER, 8), i0.inject(i2.TRANSLOCO_TRANSPILER), i0.inject(i3.TRANSLOCO_MISSING_HANDLER), i0.inject(i4.TRANSLOCO_INTERCEPTOR), i0.inject(i5.TRANSLOCO_CONFIG), i0.inject(i6.TRANSLOCO_FALLBACK_STRATEGY)); }, token: TranslocoService, providedIn: "root" });
if (false) {
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.subscription;
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.translations;
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.cache;
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.firstFallbackLang;
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.defaultLang;
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.mergedConfig;
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.availableLangs;
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.isResolvedMissingOnce;
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.lang;
    /** @type {?} */
    TranslocoService.prototype.langChanges$;
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.events;
    /** @type {?} */
    TranslocoService.prototype.events$;
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.failedLangs;
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.loader;
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.parser;
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.missingHandler;
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.interceptor;
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.userConfig;
    /**
     * @type {?}
     * @private
     */
    TranslocoService.prototype.fallbackStrategy;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transloco.service.js","sourceRoot":"ng://@ngneat/transloco/","sources":["lib/transloco.service.ts"],"names":[],"mappings":"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