@ngx-translate/core
Version:
Translation library (i18n) for Angular
1,431 lines (1,430 loc) • 49.8 kB
JavaScript
import * as i0 from "@angular/core";
import { ChangeDetectionStrategy, ChangeDetectorRef, Component, DestroyRef, Directive, ElementRef, Injectable, InjectionToken, Injector, Input, Pipe, TemplateRef, ViewContainerRef, computed, contentChildren, effect, inject, input, signal, untracked } from "@angular/core";
import { takeUntilDestroyed } from "@angular/core/rxjs-interop";
import { EMPTY, ReplaySubject, Subject, concat, defer, finalize, firstValueFrom, forkJoin, isObservable, merge, of, retry, share, tap, throwError, timer } from "rxjs";
import { catchError, concatMap, defaultIfEmpty, filter, map, switchMap, take, takeUntil } from "rxjs/operators";
import { NgTemplateOutlet } from "@angular/common";
function _(key) {
return key;
}
function omit(map, key) {
const next = {};
for (const k of Object.keys(map)) if (k !== key) next[k] = map[k];
return next;
}
var LoadingTranslationsRegistry = class {
state = signal({}, ...ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []);
hasAny = computed(() => Object.keys(this.state()).length > 0, ...ngDevMode ? [{ debugName: "hasAny" }] : /* istanbul ignore next */ []);
isLoading(lang) {
return this.state()[lang] !== void 0;
}
get(lang) {
return this.state()[lang];
}
set(lang, obs) {
this.state.update((m) => ({
...m,
[lang]: obs
}));
}
clear(lang) {
this.state.update((m) => omit(m, lang));
}
clearIfOwner(lang, token) {
this.state.update((m) => m[lang] === token ? omit(m, lang) : m);
}
};
var MissingTranslationHandler = class {};
var DefaultMissingTranslationHandler = class DefaultMissingTranslationHandler {
handle(params) {
return params.key;
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: DefaultMissingTranslationHandler,
deps: [],
target: i0.ɵɵFactoryTarget.Injectable
});
static ɵprov = i0.ɵɵngDeclareInjectable({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: DefaultMissingTranslationHandler
});
};
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: DefaultMissingTranslationHandler,
decorators: [{ type: Injectable }]
});
var TranslateCompiler = class {};
var TranslateNoOpCompiler = class TranslateNoOpCompiler extends TranslateCompiler {
compile(value, lang) {
return value;
}
compileTranslations(translations, lang) {
return translations;
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateNoOpCompiler,
deps: null,
target: i0.ɵɵFactoryTarget.Injectable
});
static ɵprov = i0.ɵɵngDeclareInjectable({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateNoOpCompiler
});
};
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateNoOpCompiler,
decorators: [{ type: Injectable }]
});
var TranslateLoader = class {};
var TranslateNoOpLoader = class TranslateNoOpLoader extends TranslateLoader {
getTranslation(lang) {
return of({});
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateNoOpLoader,
deps: null,
target: i0.ɵɵFactoryTarget.Injectable
});
static ɵprov = i0.ɵɵngDeclareInjectable({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateNoOpLoader
});
};
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateNoOpLoader,
decorators: [{ type: Injectable }]
});
function equals(o1, o2) {
if (o1 === o2) return true;
if (o1 === null || o2 === null) return false;
if (o1 !== o1 && o2 !== o2) return true;
if (o1 instanceof Date || o2 instanceof Date) return o1 instanceof Date && o2 instanceof Date && equals(o1.getTime(), o2.getTime());
const t1 = typeof o1, t2 = typeof o2;
let length;
if (t1 == t2 && t1 == "object") {
if (Array.isArray(o1)) {
if (!Array.isArray(o2)) return false;
if ((length = o1.length) == o2.length) {
for (let key = 0; key < length; key++) if (!equals(o1[key], o2[key])) return false;
return true;
}
} else {
if (Array.isArray(o2)) return false;
if (isDict(o1) && isDict(o2)) {
const keySet = Object.create(null);
for (const key in o1) {
if (!equals(o1[key], o2[key])) return false;
keySet[key] = true;
}
for (const key in o2) if (!(key in keySet) && typeof o2[key] !== "undefined") return false;
return true;
}
}
}
return false;
}
function isDefinedAndNotNull(value) {
return typeof value !== "undefined" && value !== null;
}
function isDefined(value) {
return value !== void 0;
}
function isDict(value) {
return isObject(value) && !isArray(value) && value !== null;
}
function isObject(value) {
return typeof value === "object" && value !== null;
}
function isArray(value) {
return Array.isArray(value);
}
function isString(value) {
return typeof value === "string";
}
function isFunction(value) {
return typeof value === "function";
}
function cloneDeep(value) {
if (isArray(value)) return value.map((item) => cloneDeep(item));
else if (isDict(value)) {
const cloned = {};
Object.keys(value).forEach((key) => {
cloned[key] = cloneDeep(value[key]);
});
return cloned;
} else return value;
}
function mergeDeep(target, source) {
if (!isObject(target)) return cloneDeep(source);
const output = cloneDeep(target);
if (isObject(output) && isObject(source)) Object.keys(source).forEach((key) => {
if (isDict(source[key])) {
if (key in target) output[key] = mergeDeep(target[key], source[key]);
else Object.assign(output, { [key]: source[key] });
} else Object.assign(output, { [key]: source[key] });
});
return output;
}
function getValue(target, key) {
const originalTarget = target;
const originalKey = key;
const keys = key.split(".");
key = "";
do {
key += keys.shift();
const isLastKey = !keys.length;
if (isDefinedAndNotNull(target)) {
if (isDict(target) && isDefined(target[key]) && (isDict(target[key]) || isArray(target[key]) || isLastKey)) {
target = target[key];
key = "";
continue;
}
if (isArray(target)) {
if (key === "length" && isLastKey) {
target = target.length;
key = "";
continue;
}
if (/^\d+$/.test(key)) {
const index = parseInt(key, 10);
if (isDefined(target[index]) && (isDict(target[index]) || isArray(target[index]) || isLastKey)) {
target = target[index];
key = "";
continue;
}
}
}
}
if (isLastKey) {
target = void 0;
continue;
}
key += ".";
} while (keys.length);
if (typeof target === "undefined" && isDict(originalTarget) && isDefined(originalTarget[originalKey])) return originalTarget[originalKey];
return target;
}
function insertValue(target, key, value) {
return mergeDeep(target, createNestedObject(key, value));
}
function createNestedObject(dotSeparatedKey, value) {
return dotSeparatedKey.split(".").reduceRight((acc, key) => ({ [key]: acc }), value);
}
var TranslateParser = class {};
var TranslateDefaultParser = class TranslateDefaultParser extends TranslateParser {
templateMatcher = /{{\s?([^{}\s]*)\s?}}/g;
interpolate(expr, params, context) {
if (isString(expr)) return this.interpolateString(expr, params, context);
else if (isFunction(expr)) return this.interpolateFunction(expr, params, context);
}
interpolateFunction(fn, params, context) {
return fn(params, context);
}
interpolateString(expr, params, context) {
if (!params) return expr;
return expr.replace(this.templateMatcher, (substring, key) => {
const replacement = this.getInterpolationReplacement(params, key, context);
return replacement !== void 0 ? replacement : substring;
});
}
getInterpolationReplacement(params, key, context) {
return this.formatValue(getValue(params, key), context);
}
formatValue(value, context) {
if (isString(value)) return value;
if (typeof value === "number" || typeof value === "boolean") return value.toString();
if (value === null) return "null";
if (isArray(value)) return value.join(", ");
if (isObject(value)) {
if (typeof value.toString === "function" && value.toString !== Object.prototype.toString) return value.toString();
return JSON.stringify(value);
}
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateDefaultParser,
deps: null,
target: i0.ɵɵFactoryTarget.Injectable
});
static ɵprov = i0.ɵɵngDeclareInjectable({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateDefaultParser
});
};
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateDefaultParser,
decorators: [{ type: Injectable }]
});
var TranslateStore = class TranslateStore {
_translations = signal({}, ...ngDevMode ? [{ debugName: "_translations" }] : /* istanbul ignore next */ []);
translations = this._translations.asReadonly();
_languages = signal([], ...ngDevMode ? [{ debugName: "_languages" }] : /* istanbul ignore next */ []);
languages = this._languages.asReadonly();
_lastTranslationChange = signal(null, ...ngDevMode ? [{ debugName: "_lastTranslationChange" }] : /* istanbul ignore next */ []);
lastTranslationChange = this._lastTranslationChange.asReadonly();
_translationChange$ = new Subject();
translationChange$ = this._translationChange$.asObservable();
constructor() {
inject(DestroyRef).onDestroy(() => {
this._translationChange$.complete();
});
}
getTranslations(language) {
return this.translations()[language];
}
setTranslations(language, translations, extend) {
untracked(() => {
this._translations.update((current) => ({
...current,
[language]: extend && this.hasTranslationFor(language) ? mergeDeep(current[language], translations) : translations
}));
this.addLanguages([language]);
const event = {
lang: language,
translations: this.getTranslations(language)
};
this._lastTranslationChange.set(event);
this._translationChange$.next(event);
});
}
getLanguages() {
return this.languages();
}
addLanguages(langs) {
this._languages.update((current) => Array.from(/* @__PURE__ */ new Set([...current, ...langs])));
}
removeLanguages(langs) {
this._languages.update((current) => current.filter((lang) => !langs.includes(lang)));
}
hasTranslationFor(lang) {
return typeof this.translations()[lang] !== "undefined";
}
deleteTranslations(lang) {
untracked(() => {
if (!this.hasTranslationFor(lang)) return;
this._translations.update((current) => {
const { [lang]: _, ...rest } = current;
return rest;
});
const event = {
lang,
translations: {}
};
this._lastTranslationChange.set(event);
this._translationChange$.next(event);
});
}
getTranslationValue(language, key) {
return getValue(this.getTranslations(language), key);
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateStore,
deps: [],
target: i0.ɵɵFactoryTarget.Injectable
});
static ɵprov = i0.ɵɵngDeclareInjectable({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateStore
});
};
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateStore,
decorators: [{ type: Injectable }],
ctorParameters: () => []
});
const TRANSLATE_SERVICE_CONFIG = new InjectionToken("TRANSLATE_CONFIG");
const makeObservable = (value) => {
return isObservable(value) ? value : of(value);
};
const RETRY_DELAY_MS = 100;
const MAX_RETRY_DELAY_MS = 2 ** 31 - 1;
var TranslateService = class TranslateService {
loadingTranslations = new LoadingTranslationsRegistry();
loadCancellation = /* @__PURE__ */ new Map();
languageRequestSequence = 0;
lastFallbackRequest = 0;
languageRequestIds = /* @__PURE__ */ new WeakMap();
deletedLanguageRequests = /* @__PURE__ */ new Map();
lastUseLanguage = null;
retry;
currentLoader = inject(TranslateLoader);
compiler = inject(TranslateCompiler);
parser = inject(TranslateParser);
missingTranslationHandler = inject(MissingTranslationHandler);
store = inject(TranslateStore);
destroyRef = inject(DestroyRef);
parent;
get isRoot() {
return this.parent === null;
}
_onLangChange = new Subject();
_onFallbackLangChange = new Subject();
_currentLang = signal(null, ...ngDevMode ? [{ debugName: "_currentLang" }] : /* istanbul ignore next */ []);
_fallbackLang = signal(null, ...ngDevMode ? [{ debugName: "_fallbackLang" }] : /* istanbul ignore next */ []);
_additionalFallbackLangs = signal([], ...ngDevMode ? [{ debugName: "_additionalFallbackLangs" }] : /* istanbul ignore next */ []);
_fallbackLangs = computed(() => {
const first = this._fallbackLang();
return first === null ? [] : [first, ...this._additionalFallbackLangs()];
}, ...ngDevMode ? [{ debugName: "_fallbackLangs" }] : /* istanbul ignore next */ []);
_onTranslationRefresh = null;
_isLoading = computed(() => this.loadingTranslations.hasAny() || (this.parent?.isLoading() ?? false), ...ngDevMode ? [{ debugName: "_isLoading" }] : /* istanbul ignore next */ []);
getRoot() {
let svc = this;
while (svc.parent) svc = svc.parent;
return svc;
}
getParent() {
return this.parent;
}
getActiveRequestedLang() {
return this.getRoot().lastUseLanguage;
}
hasTranslationInChain(lang) {
for (let svc = this; svc; svc = svc.parent) if (svc.store.hasTranslationFor(lang)) return true;
return false;
}
chainTranslationChange$() {
const streams = [];
for (let svc = this; svc; svc = svc.parent) streams.push(svc.store.translationChange$);
return streams.length === 1 ? streams[0] : merge(...streams);
}
get onTranslationChange() {
return this.store.translationChange$;
}
get onLangChange() {
if (this.isRoot) return this._onLangChange.asObservable();
return this.parent ? this.parent.onLangChange : EMPTY;
}
get onFallbackLangChange() {
if (this.isRoot) return this._onFallbackLangChange.asObservable();
return this.parent ? this.parent.onFallbackLangChange : EMPTY;
}
get onTranslationRefresh() {
if (!this._onTranslationRefresh) {
const refresh$ = merge(this.onTranslationChange.pipe(filter((event) => event.lang === this.getCurrentLang() || this.getFallbackLangs().includes(event.lang))), this.onLangChange, this.onFallbackLangChange).pipe(map(() => void 0));
if (this.isRoot) this._onTranslationRefresh = refresh$;
else this._onTranslationRefresh = this.parent ? merge(refresh$, this.parent.onTranslationRefresh) : refresh$;
}
return this._onTranslationRefresh;
}
constructor() {
const config = {
isRoot: true,
fallbackLang: null,
...inject(TRANSLATE_SERVICE_CONFIG, { optional: true })
};
this.parent = config.isRoot ? null : inject(TranslateService, {
optional: true,
skipSelf: true
});
if (typeof config.retry === "object") {
const { count, delay, shouldRetry } = config.retry;
this.retry = {
count,
delay: typeof delay === "function" ? delay.bind(config.retry) : delay,
shouldRetry: shouldRetry?.bind(config.retry)
};
} else this.retry = Math.max(0, config.retry ?? 0);
const destroyRef = inject(DestroyRef);
if (this.isRoot) {
if (config.langs?.length) this.addLangs(config.langs);
if (config.lang) this.use(config.lang);
if (config.fallbackLangs !== void 0) this.setFallbackLangs(config.fallbackLangs);
else if (config.fallbackLang) this.setFallbackLang(config.fallbackLang);
} else {
const currentLang = this.getCurrentLang();
if (currentLang) this.loadOrExtendLanguage(currentLang)?.pipe(takeUntilDestroyed(destroyRef)).subscribe({ error: (err) => {
console.warn(`-translate/core: child failed to load "${currentLang}". Cause:`, err);
} });
for (const fallbackLang of this.getFallbackLangs()) if (fallbackLang && fallbackLang !== currentLang) this.loadOrExtendLanguage(fallbackLang)?.pipe(takeUntilDestroyed(destroyRef)).subscribe({ error: (err) => {
console.warn(`-translate/core: child failed to load "${fallbackLang}". Cause:`, err);
} });
}
this.onLangChange.pipe(takeUntilDestroyed(destroyRef)).subscribe((event) => {
if (!this.isRoot && this.shouldLoadLanguage(event)) this.loadOrExtendLanguage(event.lang)?.pipe(takeUntilDestroyed(destroyRef)).subscribe({ error: (err) => {
console.warn(`-translate/core: child failed to load "${event.lang}". Cause:`, err);
} });
});
this.onFallbackLangChange.pipe(takeUntilDestroyed(destroyRef)).subscribe((event) => {
if (this.isRoot) return;
for (const lang of event.langs ?? [event.lang]) if (this.shouldLoadLanguage(event, lang)) this.loadOrExtendLanguage(lang)?.pipe(takeUntilDestroyed(destroyRef)).subscribe({ error: (err) => {
console.warn(`-translate/core: child failed to load "${lang}". Cause:`, err);
} });
});
destroyRef.onDestroy(() => {
this._onLangChange.complete();
this._onFallbackLangChange.complete();
});
}
shouldLoadLanguage(event, lang = event.lang) {
const deletedAt = this.deletedLanguageRequests.get(lang);
const requestId = this.getRoot().languageRequestIds.get(event);
return deletedAt === void 0 || requestId === void 0 || requestId > deletedAt;
}
setFallbackLang(lang) {
if (!this.isRoot) return this.parent.setFallbackLang(lang);
return this.setFallbackLangs([lang]).pipe(map((translations) => translations[0]));
}
setFallbackLangs(languages) {
if (!this.isRoot) return this.parent.setFallbackLangs(languages);
return untracked(() => {
const langs = [...new Set(languages)];
const requestId = ++this.languageRequestSequence;
this.lastFallbackRequest = requestId;
if (this._fallbackLang() === null) this.setFallbackLanguageState(langs);
const pending = langs.length ? forkJoin(langs.map((lang) => (this.loadOrExtendLanguage(lang) ?? of(this.store.getTranslations(lang))).pipe(take(1)))) : of([]);
pending.pipe(takeUntilDestroyed(this.destroyRef)).subscribe({
next: (translations) => {
if (this.lastFallbackRequest !== requestId || langs.some((lang) => (this.deletedLanguageRequests.get(lang) ?? -1) >= requestId)) return;
this.setFallbackLanguageState(langs);
const event = {
lang: langs[0] ?? "",
translations: translations[0] ?? {},
...langs.length !== 1 && { langs: this.getFallbackLangs() }
};
this.languageRequestIds.set(event, requestId);
this._onFallbackLangChange.next(event);
},
error: (err) => {
console.warn(`-translate/core: failed to load fallback "${langs.join(", ")}". Cause:`, err);
}
});
return pending;
});
}
setFallbackLanguageState(langs) {
this._additionalFallbackLangs.set(langs.slice(1));
this._fallbackLang.set(langs[0] ?? null);
}
get isLoading() {
return this._isLoading;
}
use(lang) {
if (!this.isRoot) return this.parent.use(lang);
return untracked(() => {
const requestId = ++this.languageRequestSequence;
const prevLang = this._currentLang();
const prevLastUseLang = this.lastUseLanguage;
this.lastUseLanguage = lang;
if (!this._currentLang()) this._currentLang.set(lang);
const pending = this.loadOrExtendLanguage(lang);
if (!isObservable(pending)) {
this.changeLang(lang, requestId);
return of(this.store.getTranslations(lang));
}
pending.pipe(take(1)).subscribe({
next: () => {
this.changeLang(lang, requestId);
},
error: (err) => {
if (this.lastUseLanguage === lang && (typeof this.retry === "number" || !this.store.hasTranslationFor(lang))) {
this._currentLang.set(prevLang);
this.lastUseLanguage = prevLastUseLang;
}
console.warn(`-translate/core: failed to load "${lang}". currentLang was NOT changed; remains "${prevLang ?? "null"}". Cause:`, err);
}
});
return pending;
});
}
loadOrExtendLanguage(lang) {
if (!this.store.hasTranslationFor(lang)) return this.loadAndCompileTranslations(lang);
return of(this.store.getTranslations(lang));
}
getTranslations(language) {
return this.store.getTranslations(language);
}
changeLang(lang, requestId) {
if (lang !== this.lastUseLanguage) return;
this._currentLang.set(lang);
const event = {
lang,
translations: this.store.getTranslations(lang)
};
if (requestId !== void 0) this.languageRequestIds.set(event, requestId);
this._onLangChange.next(event);
}
getCurrentLang() {
return this.isRoot ? this._currentLang() : this.parent?.getCurrentLang() ?? null;
}
loadAndCompileTranslations(lang) {
const existing = this.loadingTranslations.get(lang);
if (existing) return existing;
const retryConfig = typeof this.retry === "number" ? { count: this.retry } : this.retry;
let cancellation = this.loadCancellation.get(lang);
if (!cancellation) {
cancellation = new ReplaySubject(1);
this.loadCancellation.set(lang, cancellation);
}
const source$ = defer(() => {
const source = this.currentLoader.getTranslation(lang);
return retryConfig.count > 0 ? source.pipe(retry({
count: retryConfig.count,
delay: (error, retryAttempt) => {
if (retryConfig.shouldRetry && !retryConfig.shouldRetry(error)) return throwError(() => error);
const delay = retryConfig.delay ?? RETRY_DELAY_MS;
const delayMs = typeof delay === "function" ? delay(error, retryAttempt) : delay;
if (!Number.isFinite(delayMs) || delayMs < 0 || delayMs > MAX_RETRY_DELAY_MS) throw new RangeError("@ngx-translate/core: retry delay must be a finite number between 0 and 2147483647 milliseconds.");
return timer(delayMs);
}
})) : source;
});
let completed = false;
const shared$ = source$.pipe(map((res) => this.compiler.compileTranslations(res, lang)), filter(() => this.loadCancellation.get(lang) === cancellation), tap({
next: (compiled) => {
this.store.setTranslations(lang, compiled, false);
this.loadingTranslations.clearIfOwner(lang, translations$);
},
error: () => {
if (typeof this.retry !== "number") this.loadingTranslations.clearIfOwner(lang, translations$);
}
}), catchError((error) => this.loadCancellation.get(lang) === cancellation ? throwError(() => error) : EMPTY), tap({ complete: () => {
completed = this.loadCancellation.get(lang) === cancellation;
} }), takeUntil(cancellation), finalize(() => this.loadingTranslations.clearIfOwner(lang, translations$)), share({
connector: () => new ReplaySubject(1),
resetOnError: typeof this.retry === "number",
resetOnComplete: false,
resetOnRefCountZero: true
}));
const translations$ = defer(() => completed || this.loadCancellation.get(lang) === cancellation ? shared$ : EMPTY);
this.loadingTranslations.set(lang, translations$);
translations$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe({ error: () => {} });
return translations$;
}
setTranslation(lang, translations, shouldMerge = false) {
const interpolatableTranslations = this.compiler.compileTranslations(translations, lang);
this.store.setTranslations(lang, interpolatableTranslations, shouldMerge);
}
setCompiledTranslation(lang, translations, shouldMerge = false) {
this.store.setTranslations(lang, translations, shouldMerge);
}
getLangs() {
return this.store.getLanguages();
}
addLangs(languages) {
this.store.addLanguages(languages);
}
getParsedResultForKey(key, interpolateParams, lang) {
let lookup;
const translation = this.getTextToInterpolate(key, lang, (result) => {
lookup = result;
});
if (isDefinedAndNotNull(translation)) {
const context = lookup?.translation === translation ? lookup.context : { key };
return this.runInterpolation(translation, interpolateParams, context);
}
const res = this.getMissingTranslationHandler().handle({
key,
translateService: this,
...interpolateParams !== void 0 && { interpolateParams }
});
return res !== void 0 ? res : key;
}
getMissingTranslationHandler() {
return this.missingTranslationHandler;
}
getFallbackLang() {
return this.isRoot ? this._fallbackLang() : this.parent?.getFallbackLang() ?? null;
}
getFallbackLangs() {
return this.fallbackLangs();
}
getTextToInterpolate(key, lang, onLookup) {
if (lang) {
const res = this.store.getTranslationValue(lang, key);
if (res !== void 0) {
onLookup?.({
translation: res,
context: {
key,
lang
}
});
return res;
}
return this.parent?.getTextToInterpolate(key, lang, onLookup);
}
const currentLang = this.getCurrentLang();
let res;
let resLang;
if (currentLang) {
res = this.store.getTranslationValue(currentLang, key);
resLang = currentLang;
}
for (const fallbackLang of this.getFallbackLangs()) {
if (isDefinedAndNotNull(res)) break;
if (fallbackLang !== currentLang) {
res = this.store.getTranslationValue(fallbackLang, key);
resLang = fallbackLang;
}
}
if (res !== void 0) {
onLookup?.({
translation: res,
context: resLang === void 0 ? { key } : {
key,
lang: resLang
}
});
return res;
}
return this.parent?.getTextToInterpolate(key, lang, onLookup);
}
runInterpolation(translations, interpolateParams, context) {
if (!isDefinedAndNotNull(translations)) return;
if (isArray(translations)) return this.runInterpolationOnArray(translations, interpolateParams, context);
if (isDict(translations)) return this.runInterpolationOnDict(translations, interpolateParams, context);
return this.parser.interpolate(translations, interpolateParams, context);
}
runInterpolationOnArray(translations, interpolateParams, context) {
return translations.map((translation) => this.runInterpolation(translation, interpolateParams, context));
}
runInterpolationOnDict(translations, interpolateParams, context) {
const result = {};
for (const key in translations) {
const res = this.runInterpolation(translations[key], interpolateParams, context);
if (res !== void 0) result[key] = res;
}
return result;
}
getParsedResult(key, interpolateParams, lang) {
return key instanceof Array ? this.getParsedResultForArray(key, interpolateParams, lang) : this.getParsedResultForKey(key, interpolateParams, lang);
}
getParsedResultForArray(key, interpolateParams, lang) {
const result = {};
let observables = false;
for (const k of key) {
result[k] = this.getParsedResultForKey(k, interpolateParams, lang);
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;
}));
}
get(key, interpolateParams, lang) {
if (!isDefinedAndNotNull(key) || !key.length) return of("");
const effectiveLang = lang ?? this.getActiveRequestedLang() ?? this.getCurrentLang();
const observed = /* @__PURE__ */ new Set();
const waitForTranslations = () => {
const languages = /* @__PURE__ */ new Set([...effectiveLang ? [effectiveLang] : [], ...lang ? [] : this.getFallbackLangs()]);
const pending = [];
for (let service = this; service; service = service.parent) for (const language of languages) {
const load = service.loadingTranslations.get(language);
if (load && !observed.has(load)) {
observed.add(load);
pending.push(load.pipe(take(1), defaultIfEmpty(void 0)));
}
}
return pending.length ? forkJoin(pending).pipe(concatMap(waitForTranslations)) : makeObservable(this.getParsedResult(key, interpolateParams, lang));
};
return waitForTranslations();
}
getAsync(key, interpolateParams, lang) {
return firstValueFrom(this.get(key, interpolateParams, lang));
}
getStreamOnTranslationChange(key, interpolateParams, lang) {
if (!isDefinedAndNotNull(key) || !key.length) throw new Error(`Parameter "key" is required and cannot be empty`);
return concat(defer(() => this.get(key, interpolateParams, lang)), this.onTranslationChange.pipe(switchMap(() => {
const res = this.getParsedResult(key, interpolateParams, lang);
return makeObservable(res);
})));
}
stream(key, interpolateParams, lang) {
if (!isDefinedAndNotNull(key) || !key.length) throw new Error(`Parameter "key" required`);
const reemit$ = lang ? merge(this.onLangChange, this.chainTranslationChange$().pipe(filter((e) => e.lang === lang))) : this.onLangChange;
return concat(defer(() => this.get(key, interpolateParams, lang)), reemit$.pipe(switchMap(() => {
const res = this.getParsedResult(key, interpolateParams, lang);
return makeObservable(res);
})));
}
instant(key, interpolateParams, lang) {
if (!isDefinedAndNotNull(key) || key.length === 0) return "";
if (lang && !this.hasTranslationInChain(lang)) this.warnUnloadedInstantLang(lang);
const result = this.getParsedResult(key, interpolateParams, lang);
return isObservable(result) ? this.keyToObject(key) : result;
}
warnedUnloadedInstantLangs = /* @__PURE__ */ new Set();
warnUnloadedInstantLang(lang) {
const root = this.getRoot();
if (root !== this) {
root.warnUnloadedInstantLang(lang);
return;
}
if (this.warnedUnloadedInstantLangs.has(lang)) return;
untracked(() => {
this.warnedUnloadedInstantLangs.add(lang);
console.warn(`-translate/core: instant() called with lang="${lang}" but no translations are loaded for that language. Returning the key as fallback. Load with use("${lang}") or setTranslation("${lang}", ...) first.`);
});
}
hasTranslationKey(key, lang) {
if (!isDefinedAndNotNull(key) || key.length === 0) return false;
return isDefinedAndNotNull(this.getTextToInterpolate(key, lang));
}
translate(key, params, lang) {
return computed(() => {
const currentKey = typeof key === "function" ? key() : key;
const currentParams = typeof params === "function" ? params() : params;
const currentLang = typeof lang === "function" ? lang() : lang;
return this.instant(currentKey, currentParams, currentLang);
});
}
keyToObject(key) {
if (Array.isArray(key)) return key.reduce((acc, currKey) => {
acc[currKey] = currKey;
return acc;
}, {});
return key;
}
set(key, translation, lang) {
untracked(() => {
const targetLang = lang ?? this.getCurrentLang();
this.store.setTranslations(targetLang, insertValue(this.store.getTranslations(targetLang), key, isString(translation) ? this.compiler.compile(translation, targetLang) : this.compiler.compileTranslations(translation, targetLang)), false);
});
}
reloadLang(lang) {
return untracked(() => {
this.resetLang(lang);
return this.loadAndCompileTranslations(lang);
});
}
resetLang(lang) {
this.loadingTranslations.clear(lang);
this.store.deleteTranslations(lang);
}
deleteLanguage(lang) {
untracked(() => {
this.deletedLanguageRequests.set(lang, this.getRoot().languageRequestSequence);
const cancellation = this.loadCancellation.get(lang);
this.loadCancellation.delete(lang);
this.loadingTranslations.clear(lang);
this.store.removeLanguages([lang]);
this.store.deleteTranslations(lang);
cancellation?.next();
cancellation?.complete();
});
}
static getBrowserLang() {
if (typeof window === "undefined" || !window.navigator) return;
const browserLang = this.getBrowserCultureLang();
return browserLang ? browserLang.split(/[-_]/)[0] : void 0;
}
static getBrowserCultureLang() {
if (typeof window === "undefined" || typeof window.navigator === "undefined") return;
return window.navigator.languages ? window.navigator.languages[0] : window.navigator.language || window.navigator.browserLanguage || window.navigator.userLanguage;
}
getBrowserLang() {
return TranslateService.getBrowserLang();
}
getBrowserCultureLang() {
return TranslateService.getBrowserCultureLang();
}
get currentLang() {
return this.isRoot ? this._currentLang.asReadonly() : this.parent.currentLang;
}
get fallbackLang() {
return this.isRoot ? this._fallbackLang.asReadonly() : this.parent.fallbackLang;
}
get fallbackLangs() {
return this.isRoot ? this._fallbackLangs : this.parent.fallbackLangs;
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateService,
deps: [],
target: i0.ɵɵFactoryTarget.Injectable
});
static ɵprov = i0.ɵɵngDeclareInjectable({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateService
});
};
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateService,
decorators: [{ type: Injectable }],
ctorParameters: () => []
});
function translate(key, params, lang) {
return inject(TranslateService).translate(key, params, lang);
}
var TranslateBlockContext = class {
$implicit;
constructor($implicit) {
this.$implicit = $implicit;
}
};
var TranslateBlockDirective = class TranslateBlockDirective {
templateRef = inject(TemplateRef);
viewContainer = inject(ViewContainerRef);
translateService = inject(TranslateService);
ngOnInit() {
const translateFn = (key, params) => {
return this.translateService.instant(key, params);
};
this.viewContainer.createEmbeddedView(this.templateRef, new TranslateBlockContext(translateFn));
}
static ngTemplateContextGuard(_dir, _ctx) {
return true;
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateBlockDirective,
deps: [],
target: i0.ɵɵFactoryTarget.Directive
});
static ɵdir = i0.ɵɵngDeclareDirective({
minVersion: "14.0.0",
version: "22.2.3",
type: TranslateBlockDirective,
isStandalone: true,
selector: "[translateBlock]",
ngImport: i0
});
};
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateBlockDirective,
decorators: [{
type: Directive,
args: [{
selector: "[translateBlock]",
standalone: true
}]
}]
});
var ContentKeyHandler = class {
element;
changeDetectorRef;
translateService;
lastParams;
constructor(element, changeDetectorRef, translateService) {
this.element = element;
this.changeDetectorRef = changeDetectorRef;
this.translateService = translateService;
console.warn("@ngx-translate/core: Using element content as a translation key is deprecated and will be removed in v19. Use [translate]=\"'KEY'\" or *translateBlock=\"let t\" instead.", this.element?.nativeElement);
}
checkNodes(currentParams, forceUpdate = false) {
const nodes = this.element.nativeElement.childNodes;
if (!nodes.length) return;
nodes.forEach((n) => {
const node = n;
if (node.nodeType === 3) {
let key;
if (forceUpdate) node.lastKey = null;
if (isDefinedAndNotNull(node.lookupKey)) key = node.lookupKey;
else {
const content = this.getContent(node);
const trimmedContent = content.trim();
if (trimmedContent.length) {
node.lookupKey = trimmedContent;
if (content !== node.currentValue) {
key = trimmedContent;
node.originalContent = content || node.originalContent;
} else if (node.originalContent) key = node.originalContent.trim();
}
}
this.updateValue(key, node, currentParams);
}
});
}
updateValue(key, node, currentParams) {
if (!key) return;
if (node.lastKey === key && this.lastParams === currentParams) return;
this.lastParams = currentParams;
const res = this.translateService.instant(key, currentParams);
if (res !== key || !node.lastKey) node.lastKey = key;
if (!node.originalContent) node.originalContent = this.getContent(node);
if (isString(res)) node.currentValue = res;
else if (!isDefinedAndNotNull(res)) node.currentValue = node.originalContent || key;
else node.currentValue = JSON.stringify(res);
this.setContent(node, node.originalContent.replace(key, node.currentValue));
this.changeDetectorRef.markForCheck();
}
getContent(node) {
return isDefinedAndNotNull(node.textContent) ? node.textContent : node.data;
}
setContent(node, content) {
if (isDefinedAndNotNull(node.textContent)) node.textContent = content;
else node.data = content;
}
};
var TranslateDirective = class TranslateDirective {
translateService = inject(TranslateService);
element = inject(ElementRef);
destroyRef = inject(DestroyRef);
changeDetectorRef = inject(ChangeDetectorRef);
injector = inject(Injector);
key;
currentParams;
keySignal = null;
paramsSignal = null;
translationSignal = null;
effectCreated = false;
contentKeyHandler = null;
set translate(key) {
if (key) {
this.key = key;
if (!this.keySignal) {
this.keySignal = signal(key, ...ngDevMode ? [{ debugName: "keySignal" }] : /* istanbul ignore next */ []);
this.paramsSignal = signal(this.currentParams, ...ngDevMode ? [{ debugName: "paramsSignal" }] : /* istanbul ignore next */ []);
this.translationSignal = this.translateService.translate(this.keySignal, this.paramsSignal);
this.setupEffect();
} else this.keySignal.set(key);
}
}
set ngxTranslate(key) {
this.translate = key;
}
set translateParams(params) {
if (!equals(this.currentParams, params)) {
this.currentParams = params;
if (this.paramsSignal) this.paramsSignal.set(params);
else if (this.contentKeyHandler) this.contentKeyHandler.checkNodes(params, true);
}
}
constructor() {
this.translateService.onTranslationRefresh.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => {
if (this.translationSignal) this.writeTranslationToDOM();
else if (this.contentKeyHandler) this.contentKeyHandler.checkNodes(this.currentParams, true);
});
}
ngAfterViewChecked() {
if (!this.keySignal && !this.contentKeyHandler) this.contentKeyHandler = new ContentKeyHandler(this.element, this.changeDetectorRef, this.translateService);
if (this.contentKeyHandler) this.contentKeyHandler.checkNodes(this.currentParams);
}
setupEffect() {
if (this.effectCreated) return;
this.effectCreated = true;
effect(() => {
const value = this.translationSignal();
this.writeToDOM(value);
}, { injector: this.injector });
}
writeTranslationToDOM() {
if (this.translationSignal) {
const value = this.translationSignal();
this.writeToDOM(value);
}
}
writeToDOM(value) {
const el = this.element.nativeElement;
let text;
if (isString(value)) text = value;
else if (!isDefinedAndNotNull(value)) text = this.key;
else text = JSON.stringify(value);
el.textContent = text;
this.changeDetectorRef.markForCheck();
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateDirective,
deps: [],
target: i0.ɵɵFactoryTarget.Directive
});
static ɵdir = i0.ɵɵngDeclareDirective({
minVersion: "14.0.0",
version: "22.2.3",
type: TranslateDirective,
isStandalone: true,
selector: "[translate],[ngx-translate],[ngxTranslate]",
inputs: {
translate: "translate",
ngxTranslate: "ngxTranslate",
translateParams: "translateParams"
},
ngImport: i0
});
};
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateDirective,
decorators: [{
type: Directive,
args: [{
selector: "[translate],[ngx-translate],[ngxTranslate]",
standalone: true
}]
}],
ctorParameters: () => [],
propDecorators: {
translate: [{ type: Input }],
ngxTranslate: [{ type: Input }],
translateParams: [{ type: Input }]
}
});
var TranslateSlotDirective = class TranslateSlotDirective {
name = input.required({
...ngDevMode ? { debugName: "name" } : /* istanbul ignore next */ {},
alias: "translateSlot"
});
template = inject(TemplateRef);
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateSlotDirective,
deps: [],
target: i0.ɵɵFactoryTarget.Directive
});
static ɵdir = i0.ɵɵngDeclareDirective({
minVersion: "17.1.0",
version: "22.2.3",
type: TranslateSlotDirective,
isStandalone: true,
selector: "ng-template[translateSlot]",
inputs: { name: {
classPropertyName: "name",
publicName: "translateSlot",
isSignal: true,
isRequired: true,
transformFunction: null
} },
ngImport: i0
});
};
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateSlotDirective,
decorators: [{
type: Directive,
args: [{
selector: "ng-template[translateSlot]",
standalone: true
}]
}],
propDecorators: { name: [{
type: i0.Input,
args: [{
isSignal: true,
alias: "translateSlot",
required: true
}]
}] }
});
var TranslateSlotsComponent = class TranslateSlotsComponent {
key = input.required({
...ngDevMode ? { debugName: "key" } : /* istanbul ignore next */ {},
alias: "translateSlots"
});
translateParams = input(...ngDevMode ? [void 0, { debugName: "translateParams" }] : /* istanbul ignore next */ []);
translate = inject(TranslateService);
slots = contentChildren(TranslateSlotDirective, ...ngDevMode ? [{ debugName: "slots" }] : /* istanbul ignore next */ []);
marker = `\uE000${Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)}\uE000`;
parts = computed(() => {
const slots = this.slots();
const translateParams = this.translateParams();
const params = { ...translateParams };
const names = /* @__PURE__ */ new Set();
for (const [index, slot] of slots.entries()) {
const name = slot.name();
if (names.has(name)) throw new Error(`-translate/core: duplicate translateSlot "${name}".`);
if (getValue(translateParams, name) !== void 0) throw new Error(`-translate/core: translateSlot "${name}" is also passed in translateParams.`);
names.add(name);
params[name] = `${this.marker}${index}${this.marker}`;
}
const translation = this.translate.instant(this.key(), params);
const occurrences = /* @__PURE__ */ new Map();
return (isString(translation) ? translation : this.key()).split(this.marker).flatMap((chunk, index) => {
if (index % 2 === 0) return chunk ? [{
id: `text:${index}`,
text: chunk
}] : [];
const slot = slots[Number(chunk)];
const occurrence = occurrences.get(slot.name()) ?? 0;
occurrences.set(slot.name(), occurrence + 1);
return [{
id: `slot:${slot.name()}:${occurrence}`,
template: slot.template
}];
});
}, ...ngDevMode ? [{ debugName: "parts" }] : /* istanbul ignore next */ []);
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateSlotsComponent,
deps: [],
target: i0.ɵɵFactoryTarget.Component
});
static ɵcmp = i0.ɵɵngDeclareComponent({
minVersion: "17.0.0",
version: "22.2.3",
type: TranslateSlotsComponent,
isStandalone: true,
selector: "[translateSlots]",
inputs: {
key: {
classPropertyName: "key",
publicName: "translateSlots",
isSignal: true,
isRequired: true,
transformFunction: null
},
translateParams: {
classPropertyName: "translateParams",
publicName: "translateParams",
isSignal: true,
isRequired: false,
transformFunction: null
}
},
queries: [{
propertyName: "slots",
predicate: TranslateSlotDirective,
isSignal: true
}],
ngImport: i0,
template: "@for (part of parts(); track part.id) {\n @if (part.template) {\n <ng-container [ngTemplateOutlet]=\"part.template\" />\n } @else {\n <ng-container>{{ part.text }}</ng-container>\n }\n}\n",
dependencies: [{
kind: "directive",
type: NgTemplateOutlet,
selector: "[ngTemplateOutlet]",
inputs: [
"ngTemplateOutletContext",
"ngTemplateOutlet",
"ngTemplateOutletInjector"
]
}],
changeDetection: i0.ChangeDetectionStrategy.OnPush
});
};
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslateSlotsComponent,
decorators: [{
type: Component,
args: [{
selector: "[translateSlots]",
standalone: true,
imports: [NgTemplateOutlet],
changeDetection: ChangeDetectionStrategy.OnPush,
template: "@for (part of parts(); track part.id) {\n @if (part.template) {\n <ng-container [ngTemplateOutlet]=\"part.template\" />\n } @else {\n <ng-container>{{ part.text }}</ng-container>\n }\n}\n"
}]
}],
propDecorators: {
key: [{
type: i0.Input,
args: [{
isSignal: true,
alias: "translateSlots",
required: true
}]
}],
translateParams: [{
type: i0.Input,
args: [{
isSignal: true,
alias: "translateParams",
required: false
}]
}],
slots: [{
type: i0.ContentChildren,
args: [i0.forwardRef(() => TranslateSlotDirective), { isSignal: true }]
}]
}
});
var TranslatePipe = class TranslatePipe {
translateService = inject(TranslateService);
cachedSignal = null;
lastKey = null;
lastParams;
transform(query, ...args) {
if (!query || !query.length) return query;
const interpolateParams = this.parseArgs(args);
if (query !== this.lastKey || !equals(interpolateParams, this.lastParams)) {
this.cachedSignal = this.translateService.translate(query, interpolateParams);
this.lastKey = query;
this.lastParams = interpolateParams;
}
return this.cachedSignal();
}
parseArgs(args) {
if (!isDefinedAndNotNull(args[0]) || !args.length) return;
if (isString(args[0]) && args[0].length) {
const validArgs = args[0].replace(/(')?([a-zA-Z0-9_]+)(')?(\s)?:/g, "\"$2\":").replace(/:(\s)?(')(.*?)(')/g, ":\"$3\"");
try {
return JSON.parse(validArgs);
} catch (e) {
throw new SyntaxError(`Wrong parameter in TranslatePipe. Expected a valid Object, received: ${args[0]}`, { cause: e });
}
}
if (isDict(args[0])) return args[0];
}
static ɵfac = i0.ɵɵngDeclareFactory({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslatePipe,
deps: [],
target: i0.ɵɵFactoryTarget.Pipe
});
static ɵpipe = i0.ɵɵngDeclarePipe({
minVersion: "14.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslatePipe,
isStandalone: true,
name: "translate",
pure: false
});
static ɵprov = i0.ɵɵngDeclareInjectable({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslatePipe
});
};
i0.ɵɵngDeclareClassMetadata({
minVersion: "12.0.0",
version: "22.2.3",
ngImport: i0,
type: TranslatePipe,
decorators: [{ type: Injectable }, {
type: Pipe,
args: [{
name: "translate",
standalone: true,
pure: false
}]
}]
});
function isClass(fn) {
return /^class[{\s]/.test(Function.prototype.toString.call(fn));
}
function toProvider(token, value) {
return isClass(value) ? {
provide: token,
useClass: value
} : {
provide: token,
useFactory: value
};
}
function provideTranslateLoader(loaderOrFactory) {
return toProvider(TranslateLoader, loaderOrFactory);
}
function provideTranslateCompiler(compilerOrFactory) {
return toProvider(TranslateCompiler, compilerOrFactory);
}
function provideTranslateParser(parserOrFactory) {
return toProvider(TranslateParser, parserOrFactory);
}
function provideMissingTranslationHandler(handlerOrFactory) {
return toProvider(MissingTranslationHandler, handlerOrFactory);
}
function provideTranslateService(config = {}) {
return defaultProviders({
...config,
isRoot: true
});
}
function provideChildTranslateService(config = {}) {
return defaultProviders({
...config,
isRoot: false
});
}
function resolvePluginProvider(token, value, defaultClass, fieldName, helperName) {
if (value === void 0) return toProvider(token, defaultClass);
if (typeof value === "function") {
if (isClass(value)) {
const className = value.name || "YourClass";
console.warn(`-translate/core: "${fieldName}" received a bare class (${className}); auto-wrapping with ${helperName}(). For clarity, prefer ${fieldName}: ${helperName}(${className}).`);
}
return toProvider(token, value);
}
return value;
}
function defaultProviders(config) {
const providers = [];
const loader = resolvePluginProvider(TranslateLoader, config.loader, TranslateNoOpLoader, "loader", "provideTranslateLoader");
const compiler = resolvePluginProvider(TranslateCompiler, config.compiler, TranslateNoOpCompiler, "compiler", "provideTranslateCompiler");
const parser = resolvePluginProvider(TranslateParser, config.parser, TranslateDefaultParser, "parser", "provideTranslateParser");
const missingTranslationHandler = resolvePluginProvider(MissingTranslationHandler, config.missingTranslationHandler, DefaultMissingTranslationHandler, "missingTranslationHandler", "provideMissingTranslationHandler");
providers.push(loader, compiler, parser, missingTranslationHandler);
providers.push(TranslateStore);
const serviceConfig = {
fallbackLang: config.fallbackLang ?? null,
...config.fallbackLangs !== void 0 && { fallbackLangs: config.fallbackLangs },
lang: config.lang,
retry: config.retry,
langs: config.langs,
isRoot: config.isRoot
};
providers.push({
provide: TRANSLATE_SERVICE_CONFIG,
useValue: serviceConfig
});
providers.push({
provide: TranslateService,
useClass: TranslateService
});
return providers;
}
var ITranslateService = class {};
export { DefaultMissingTranslationHandler, ITranslateService, MissingTranslationHandler, TRANSLATE_SERVICE_CONFIG, TranslateBlockContext, TranslateBlockDirective, TranslateCompiler, TranslateDefaultParser, TranslateDirective, TranslateLoader, TranslateNoOpCompiler, TranslateNoOpLoader, TranslateParser, TranslatePipe, TranslateService, TranslateSlotDirective, TranslateSlotsComponent, TranslateStore, _, equals, getValue, insertValue, isArray, isDefined, isDefinedAndNotNull, isDict, isFunction, isObject, isString, mergeDeep, provideChildTranslateService, provideMissingTranslationHandler, provideTranslateCompiler, provideTranslateLoader, provideTranslateParser, provideTranslateService, translate };
//# sourceMappingURL=ngx-translate-core.mjs.map