@igo2/core
Version:
227 lines (217 loc) • 8.78 kB
JavaScript
import * as i0 from '@angular/core';
import { NgModule, Injectable, makeEnvironmentProviders, APP_INITIALIZER, importProvidersFrom } from '@angular/core';
import * as i1 from '@ngx-translate/core';
import { TranslateModule, TranslateLoader, MissingTranslationHandler, TranslateFakeLoader } from '@ngx-translate/core';
import { HttpClient, HttpBackend } from '@angular/common/http';
import { ObjectUtils } from '@igo2/utils';
import { BehaviorSubject, of, forkJoin, map, tap, first, switchMap, combineLatest } from 'rxjs';
import { ConfigService } from '@igo2/core/config';
import { timeout, catchError } from 'rxjs/operators';
class IgoLanguageModule {
static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoLanguageModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: IgoLanguageModule, exports: [TranslateModule] });
static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoLanguageModule, imports: [TranslateModule] });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IgoLanguageModule, decorators: [{
type: NgModule,
args: [{
exports: [TranslateModule]
}]
}] });
class LanguageLoaderBase {
}
class LanguageLoader {
httpClient;
_isLoaded$ = new BehaviorSubject(null);
isLoaded$ = this._isLoaded$.asObservable();
suffix = '.json';
prefix;
options;
constructor(handler, options) {
this.httpClient = new HttpClient(handler);
this.options = options;
}
getTranslation(lang) {
const igoLocale$ = this.httpClient.get(`locale/libs_locale/${lang}.json`);
if (!this.prefix) {
const prefix = this.options.prefix;
this.prefix = !prefix || Array.isArray(prefix) ? prefix : [prefix];
}
if (!this.prefix || this.prefix.length === 0) {
this._isLoaded$.next(true);
return this.options.ignoreLibsLocale ? of(undefined) : igoLocale$;
}
const appLocale$ = this.prefix.map((prefix) => this.httpClient.get(`${prefix}${lang}${this.suffix}`));
const locale$ = [...appLocale$];
if (!this.options.ignoreLibsLocale) {
locale$.unshift(igoLocale$);
}
return forkJoin(locale$).pipe(map((translations) => {
return translations.reduce((acc, current) => ObjectUtils.mergeDeep(acc, current), {});
}), tap(() => {
this._isLoaded$.next(true);
}));
}
}
class LanguageLoaderWithAsyncConfig extends LanguageLoader {
configService;
constructor(handler, configService, prefix, suffix = '.json') {
super(handler, undefined);
this.configService = configService;
this.prefix = prefix;
this.suffix = suffix;
}
getTranslation(lang) {
return this.configService.isLoaded$.pipe(first((isLoaded) => isLoaded), switchMap(() => {
this.options =
this.configService.getConfig('language');
return super.getTranslation(lang);
}));
}
}
class LanguageService {
translate;
language;
language$ = new BehaviorSubject(undefined);
constructor(translate) {
this.translate = translate;
if (!this.translate.defaultLang ||
!this.matchLanguage(this.translate.defaultLang)) {
this.setBrowserLanguage();
}
}
setBrowserLanguage() {
this.language = this.translate.getBrowserLang();
const lang = this.getLanguage();
this.translate.setDefaultLang(lang);
this.language$.next(lang);
}
getLanguage() {
return this.matchLanguage(this.language) ? this.language : 'en';
}
matchLanguage(lang) {
return !!lang.match(/en|fr/);
}
setLanguage(language) {
this.language = this.matchLanguage(language) ? language : 'en';
combineLatest([
this.translate.use(this.language),
this.translate.reloadLang(this.language)
]).subscribe(() => {
this.language$.next(this.language);
});
}
static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LanguageService, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LanguageService, providedIn: 'root' });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LanguageService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}], ctorParameters: () => [{ type: i1.TranslateService }] });
class IgoMissingTranslationHandler {
handle(params) {
if (!params.translateService.langs.length) {
const error = 'Translations are not yet loaded. \
Check that the LanguageService is injected.';
throw new Error(error);
}
if (params.key.substr(0, 4) === 'igo.') {
throw new Error(`The Key "${params.key}" is missing in locale file.`);
}
else {
return params.key;
}
}
}
// 5 seconds
const TIMEOUT_DURATION = 5000;
var TranslationFeatureKind;
(function (TranslationFeatureKind) {
TranslationFeatureKind[TranslationFeatureKind["Translation"] = 0] = "Translation";
})(TranslationFeatureKind || (TranslationFeatureKind = {}));
/**
* Make sure you only call this method in the root module of your application, most of the time called AppModule.
*/
function provideTranslation(featureConfig) {
return makeEnvironmentProviders([
...featureConfig.providers,
{
provide: APP_INITIALIZER,
useFactory: (languageService) => () => {
return languageService.translate.currentLoader.isLoaded$?.pipe(timeout(TIMEOUT_DURATION), first((isLoaded) => isLoaded === true), catchError((error) => {
error.message += ` - Request timed out for language loader after: ${TIMEOUT_DURATION}`;
throw error;
}));
},
deps: [LanguageService],
multi: true
}
]);
}
function withStaticConfig(options, defaultLanguage) {
const loader = {
provide: TranslateLoader,
useFactory: (http) => languageLoaderWithStatic(http, options),
deps: [HttpBackend]
};
return {
kind: TranslationFeatureKind.Translation,
providers: [
importProvidersFrom(TranslateModule.forRoot(setTranslationConfig(loader, defaultLanguage)))
]
};
}
function withAsyncConfig(defaultLanguage) {
const loader = {
provide: TranslateLoader,
useFactory: languageLoaderWithAsync,
deps: [HttpBackend, ConfigService]
};
return {
kind: TranslationFeatureKind.Translation,
providers: [
importProvidersFrom(TranslateModule.forRoot(setTranslationConfig(loader, defaultLanguage)))
]
};
}
const setTranslationConfig = (loader, defaultLanguage) => ({
defaultLanguage: defaultLanguage,
loader: loader ?? DEFAULT_LANGUAGE_LOADER,
missingTranslationHandler: {
provide: MissingTranslationHandler,
useClass: IgoMissingTranslationHandler
}
});
function languageLoaderWithStatic(http, options) {
return new LanguageLoader(http, options);
}
const LANGUAGE_LOADER = {
provide: TranslateLoader,
useFactory: languageLoaderWithAsync,
deps: [HttpBackend, ConfigService]
};
function languageLoaderWithAsync(http, config) {
return new LanguageLoaderWithAsyncConfig(http, config, undefined, undefined);
}
const DEFAULT_LANGUAGE_LOADER = {
provide: TranslateLoader,
useFactory: languageLoaderWithAsync,
deps: [HttpBackend, ConfigService]
};
function provideMockTranslation() {
return makeEnvironmentProviders([
importProvidersFrom(TranslateModule.forRoot({
loader: {
provide: TranslateLoader,
useClass: TranslateFakeLoader
}
}))
]);
}
/**
* Generated bundle index. Do not edit.
*/
export { DEFAULT_LANGUAGE_LOADER, IgoLanguageModule, IgoMissingTranslationHandler, LANGUAGE_LOADER, LanguageLoader, LanguageLoaderBase, LanguageLoaderWithAsyncConfig, LanguageService, TranslationFeatureKind, provideMockTranslation, provideTranslation, setTranslationConfig, withAsyncConfig, withStaticConfig };
//# sourceMappingURL=igo2-core-language.mjs.map