@igo2/core
Version:
265 lines (255 loc) • 10.2 kB
JavaScript
import * as i0 from '@angular/core';
import { NgModule, inject, PLATFORM_ID, Injectable, makeEnvironmentProviders, provideAppInitializer } from '@angular/core';
import * as i1 from '@ngx-translate/core';
import { TranslateModule, TranslateLoader, provideTranslateService, MissingTranslationHandler, TRANSLATE_SERVICE_CONFIG } from '@ngx-translate/core';
import { DOCUMENT, isPlatformServer } from '@angular/common';
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: "19.2.15", ngImport: i0, type: IgoLanguageModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.15", ngImport: i0, type: IgoLanguageModule, exports: [TranslateModule] });
static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: IgoLanguageModule, imports: [TranslateModule] });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", 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;
baseUrl;
constructor(handler, options) {
this.httpClient = new HttpClient(handler);
this.options = options;
const document = inject(DOCUMENT);
const platformId = inject(PLATFORM_ID);
this.baseUrl = isPlatformServer(platformId)
? this.getServerUrl(document)
: '';
}
getServerUrl(document) {
const origin = document.location.origin;
return origin.endsWith('/') ? origin : origin + '/';
}
getTranslation(lang) {
const igoLocale$ = this.httpClient.get(`${this.baseUrl}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(`${this.baseUrl}${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;
const defaultLang = this.translate.defaultLang;
if (defaultLang && this.matchLanguage(defaultLang)) {
this.language = defaultLang;
this.language$.next(defaultLang);
}
else {
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: "19.2.15", ngImport: i0, type: LanguageService, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.15", ngImport: i0, type: LanguageService, providedIn: 'root' });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.15", 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["DefaultLanguage"] = 1] = "DefaultLanguage";
})(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,
provideAppInitializer(() => {
const languageService = inject(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;
}));
})
]);
}
function withStaticConfig(options, defaultLanguage) {
const loader = {
provide: TranslateLoader,
useFactory: (http) => languageLoaderWithStatic(http, options),
deps: [HttpBackend]
};
return {
kind: TranslationFeatureKind.Translation,
providers: [
provideTranslateService(setTranslationConfig(loader, defaultLanguage))
]
};
}
function withAsyncConfig(defaultLanguage) {
const loader = {
provide: TranslateLoader,
useFactory: languageLoaderWithAsync,
deps: [HttpBackend, ConfigService]
};
return {
kind: TranslationFeatureKind.Translation,
providers: [
provideTranslateService(setTranslationConfig(loader, defaultLanguage))
]
};
}
/**
* Get the first segment of the path (e.g., '/en/alerts' => 'en')
* @param allowedLanguages default to ['fr', 'en']
*/
function withUrlDefaultLanguage(fallbackLang, allowedLanguages = ['fr', 'en']) {
return {
kind: TranslationFeatureKind.DefaultLanguage,
providers: [
{
provide: TRANSLATE_SERVICE_CONFIG,
useFactory: defaultLanguageSegmentFactory(allowedLanguages, fallbackLang)
}
]
};
}
function defaultLanguageSegmentFactory(allowedLanguages, fallbackLang) {
return () => {
const doc = inject(DOCUMENT);
const url = new URL(doc.location.href);
const firstSegment = url.pathname.split('/').filter(Boolean)[0];
if (allowedLanguages.includes(firstSegment)) {
return {
extend: true,
lang: firstSegment
};
}
return {
extend: true,
lang: fallbackLang,
fallbackLang: fallbackLang ?? 'fr'
};
};
}
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([provideTranslateService()]);
}
/**
* Generated bundle index. Do not edit.
*/
export { DEFAULT_LANGUAGE_LOADER, IgoLanguageModule, IgoMissingTranslationHandler, LANGUAGE_LOADER, LanguageLoader, LanguageLoaderBase, LanguageLoaderWithAsyncConfig, LanguageService, TranslationFeatureKind, provideMockTranslation, provideTranslation, setTranslationConfig, withAsyncConfig, withStaticConfig, withUrlDefaultLanguage };
//# sourceMappingURL=igo2-core-language.mjs.map