@o3r/localization 12.1.0-prerelease.8 → 12.1.0-prerelease.80

package/esm2022/tools/localization-translate.directive.mjs

@@ -0,0 +1,77 @@
+import { ChangeDetectorRef, Directive, ElementRef, Inject, Input, } from '@angular/core';
+import { TranslateDirective, TranslateService, } from '@ngx-translate/core';
+import { LocalizationService, } from './localization.service';
+import { LOCALIZATION_CONFIGURATION_TOKEN, } from './localization.token';
+import * as i0 from "@angular/core";
+import * as i1 from "./localization.service";
+import * as i2 from "@ngx-translate/core";
+/**
+ * TranslateDirective class adding debug functionality
+ */
+export class LocalizationTranslateDirective extends TranslateDirective {
+    /** @inheritdoc */
+    set translate(key) {
+        if (key && key !== this.key) {
+            if (this.onKeyChange) {
+                this.onKeyChange.unsubscribe();
+            }
+            this.onKeyChange = this.localizationService.getKey(key).subscribe((newKey) => {
+                this.key = newKey;
+                this.checkNodes();
+            });
+        }
+    }
+    constructor(localizationService, translateService, element, _ref, localizationConfig) {
+        super(translateService, element, _ref);
+        this.localizationService = localizationService;
+        this.localizationConfig = localizationConfig;
+        /**
+         * Should we display keys instead of translations
+         */
+        this.showKeys = false;
+        if (localizationConfig.enableTranslationDeactivation) {
+            this.onShowKeysChange = localizationService.showKeys$.subscribe((showKeys) => {
+                this.showKeys = showKeys;
+                this.checkNodes(true);
+            });
+        }
+    }
+    /**
+     * Overriding parent's setContent to plug debugging feature
+     * @param node
+     * @param content
+     */
+    setContent(node, content) {
+        const key = node.originalContent;
+        const newContent = this.showKeys ? key : (this.localizationConfig.debugMode && key ? `${key} - ${content}` : content);
+        if (typeof node.textContent !== 'undefined' && node.textContent !== null) {
+            node.textContent = newContent;
+        }
+        else {
+            node.data = newContent;
+        }
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        if (this.onShowKeysChange) {
+            this.onShowKeysChange.unsubscribe();
+        }
+        if (this.onKeyChange) {
+            this.onKeyChange?.unsubscribe();
+        }
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalizationTranslateDirective, deps: [{ token: i1.LocalizationService }, { token: i2.TranslateService }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: LOCALIZATION_CONFIGURATION_TOKEN }], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: LocalizationTranslateDirective, selector: "[translate],[ngx-translate]", inputs: { translate: "translate" }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalizationTranslateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[translate],[ngx-translate]'
+                }]
+        }], ctorParameters: () => [{ type: i1.LocalizationService }, { type: i2.TranslateService }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCALIZATION_CONFIGURATION_TOKEN]
+                }] }], propDecorators: { translate: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/tools/localization-translate.pipe.mjs

@@ -0,0 +1,86 @@
+import { ChangeDetectorRef, Inject, Pipe, } from '@angular/core';
+import { TranslatePipe, TranslateService, } from '@ngx-translate/core';
+import { LocalizationService, } from './localization.service';
+import { LOCALIZATION_CONFIGURATION_TOKEN, } from './localization.token';
+import * as i0 from "@angular/core";
+import * as i1 from "./localization.service";
+import * as i2 from "@ngx-translate/core";
+/**
+ * TranslatePipe class adding debug functionality
+ */
+export class O3rLocalizationTranslatePipe extends TranslatePipe {
+    constructor(localizationService, translateService, changeDetector, localizationConfig) {
+        super(translateService, changeDetector);
+        this.localizationService = localizationService;
+        this.changeDetector = changeDetector;
+        this.localizationConfig = localizationConfig;
+        /**
+         * Should we display keys instead of translations
+         */
+        this.showKeys = false;
+        if (localizationConfig.enableTranslationDeactivation) {
+            this.onShowKeysChange = this.localizationService.showKeys$.subscribe((showKeys) => {
+                this.showKeys = showKeys;
+                this.changeDetector.markForCheck();
+            });
+        }
+    }
+    /**
+     * Calls original transform method and eventually outputs the key if debugMode (in LocalizationConfiguration) is enabled
+     * @inheritdoc
+     */
+    transform(query, ...args) {
+        if (this.showKeys) {
+            return query;
+        }
+        if (query !== this.lastQueryKey) {
+            this.lastQueryKey = query;
+            if (this.onKeyChange) {
+                this.onKeyChange.unsubscribe();
+            }
+            this.onKeyChange = this.localizationService.getKey(query).subscribe((key) => {
+                this.lastResolvedKey = key;
+                this.changeDetector.markForCheck();
+            });
+        }
+        if (this.lastResolvedKey) {
+            const value = super.transform(this.lastResolvedKey, ...args);
+            if (this.localizationConfig.debugMode) {
+                return `${this.lastResolvedKey} - ${value}`;
+            }
+            return value;
+        }
+        return this.value;
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        if (this.onShowKeysChange) {
+            this.onShowKeysChange.unsubscribe();
+        }
+        if (this.onKeyChange) {
+            this.onKeyChange.unsubscribe();
+        }
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: O3rLocalizationTranslatePipe, deps: [{ token: i1.LocalizationService }, { token: i2.TranslateService }, { token: i0.ChangeDetectorRef }, { token: LOCALIZATION_CONFIGURATION_TOKEN }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    /** @nocollapse */ static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: O3rLocalizationTranslatePipe, name: "o3rTranslate", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: O3rLocalizationTranslatePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'o3rTranslate', pure: false }]
+        }], ctorParameters: () => [{ type: i1.LocalizationService }, { type: i2.TranslateService }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCALIZATION_CONFIGURATION_TOKEN]
+                }] }] });
+/**
+ * TranslatePipe class adding debug functionality
+ * @deprecated please use O3rLocalizationTranslatePipe, will be removed in v12.
+ */
+export class LocalizationTranslatePipe extends O3rLocalizationTranslatePipe {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalizationTranslatePipe, deps: null, target: i0.ɵɵFactoryTarget.Pipe }); }
+    /** @nocollapse */ static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: LocalizationTranslatePipe, name: "translate", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalizationTranslatePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'translate', pure: false }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/tools/localization.module.mjs

@@ -0,0 +1,89 @@
+import { BidiModule, Directionality, } from '@angular/cdk/bidi';
+import { CommonModule, CurrencyPipe, DatePipe, DecimalPipe, } from '@angular/common';
+import { InjectionToken, LOCALE_ID, NgModule, Optional, } from '@angular/core';
+import { TranslateModule, } from '@ngx-translate/core';
+import { DynamicContentModule, } from '@o3r/dynamic-content';
+import { DEFAULT_LOCALIZATION_CONFIGURATION, } from '../core';
+import { LocalizationTranslateDirective, } from './localization-translate.directive';
+import { LocalizationTranslatePipe, O3rLocalizationTranslatePipe, } from './localization-translate.pipe';
+import { LocalizationService, } from './localization.service';
+import { LOCALIZATION_CONFIGURATION_TOKEN, } from './localization.token';
+import { LocalizedCurrencyPipe, } from './localized-currency.pipe';
+import { LocalizedDatePipe, } from './localized-date.pipe';
+import { LocalizedDecimalPipe, } from './localized-decimal.pipe';
+import { TextDirectionService, } from './text-direction.service';
+import { TextDirectionality, } from './text-directionality.service';
+import * as i0 from "@angular/core";
+/**
+ * creates LocalizationConfiguration, which is used if the application
+ * @param configuration Localization configuration
+ */
+export function createLocalizationConfiguration(configuration) {
+    return {
+        ...DEFAULT_LOCALIZATION_CONFIGURATION,
+        ...configuration
+    };
+}
+/**
+ * Factory to inject the LOCALE_ID token with the current language into Angular context
+ * @param localizationService Localization service
+ */
+export function localeIdNgBridge(localizationService) {
+    return localizationService.getCurrentLanguage();
+}
+/** Custom Localization Configuration Token to override default localization configuration */
+export const CUSTOM_LOCALIZATION_CONFIGURATION_TOKEN = new InjectionToken('Partial Localization configuration');
+export class LocalizationModule {
+    /**
+     * forRoot method should be called only once from the application index.ts
+     * It will do several things:
+     * - provide the configuration for the whole application
+     * - register all locales specified in the LocalizationConfiguration
+     * - configure TranslateService
+     * - inject LOCALE_ID token
+     * @param configuration LocalizationConfiguration
+     */
+    static forRoot(configuration) {
+        return {
+            ngModule: LocalizationModule,
+            providers: [
+                LocalizationService,
+                ...(configuration
+                    ? [{
+                            provide: CUSTOM_LOCALIZATION_CONFIGURATION_TOKEN,
+                            useFactory: configuration
+                        }]
+                    : [])
+            ]
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalizationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: LocalizationModule, declarations: [O3rLocalizationTranslatePipe, LocalizationTranslatePipe, LocalizationTranslateDirective, LocalizedDatePipe, LocalizedDecimalPipe, LocalizedCurrencyPipe], imports: [TranslateModule, BidiModule, DynamicContentModule, CommonModule], exports: [TranslateModule, O3rLocalizationTranslatePipe, LocalizationTranslatePipe, LocalizationTranslateDirective, LocalizedDatePipe, LocalizedDecimalPipe, LocalizedCurrencyPipe] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalizationModule, providers: [
+            { provide: LOCALIZATION_CONFIGURATION_TOKEN, useFactory: createLocalizationConfiguration, deps: [[new Optional(), CUSTOM_LOCALIZATION_CONFIGURATION_TOKEN]] },
+            { provide: LOCALE_ID, useFactory: localeIdNgBridge, deps: [LocalizationService] },
+            { provide: Directionality, useClass: TextDirectionality },
+            { provide: DatePipe, useClass: LocalizedDatePipe },
+            { provide: DecimalPipe, useClass: LocalizedDecimalPipe },
+            { provide: CurrencyPipe, useClass: LocalizedCurrencyPipe },
+            TextDirectionService
+        ], imports: [TranslateModule, BidiModule, DynamicContentModule, CommonModule, TranslateModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalizationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [O3rLocalizationTranslatePipe, LocalizationTranslatePipe, LocalizationTranslateDirective, LocalizedDatePipe, LocalizedDecimalPipe, LocalizedCurrencyPipe],
+                    imports: [TranslateModule, BidiModule, DynamicContentModule, CommonModule],
+                    exports: [TranslateModule, O3rLocalizationTranslatePipe, LocalizationTranslatePipe, LocalizationTranslateDirective, LocalizedDatePipe, LocalizedDecimalPipe, LocalizedCurrencyPipe],
+                    providers: [
+                        { provide: LOCALIZATION_CONFIGURATION_TOKEN, useFactory: createLocalizationConfiguration, deps: [[new Optional(), CUSTOM_LOCALIZATION_CONFIGURATION_TOKEN]] },
+                        { provide: LOCALE_ID, useFactory: localeIdNgBridge, deps: [LocalizationService] },
+                        { provide: Directionality, useClass: TextDirectionality },
+                        { provide: DatePipe, useClass: LocalizedDatePipe },
+                        { provide: DecimalPipe, useClass: LocalizedDecimalPipe },
+                        { provide: CurrencyPipe, useClass: LocalizedCurrencyPipe },
+                        TextDirectionService
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"localization.module.js","sourceRoot":"","sources":["../../../src/tools/localization.module.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BidiModule,\n  Directionality,\n} from '@angular/cdk/bidi';\nimport {\n  CommonModule,\n  CurrencyPipe,\n  DatePipe,\n  DecimalPipe,\n} from '@angular/common';\nimport {\n  InjectionToken,\n  LOCALE_ID,\n  ModuleWithProviders,\n  NgModule,\n  Optional,\n} from '@angular/core';\nimport {\n  TranslateModule,\n} from '@ngx-translate/core';\nimport {\n  DynamicContentModule,\n} from '@o3r/dynamic-content';\nimport {\n  DEFAULT_LOCALIZATION_CONFIGURATION,\n  LocalizationConfiguration,\n} from '../core';\nimport {\n  LocalizationTranslateDirective,\n} from './localization-translate.directive';\nimport {\n  LocalizationTranslatePipe,\n  O3rLocalizationTranslatePipe,\n} from './localization-translate.pipe';\nimport {\n  LocalizationService,\n} from './localization.service';\nimport {\n  LOCALIZATION_CONFIGURATION_TOKEN,\n} from './localization.token';\nimport {\n  LocalizedCurrencyPipe,\n} from './localized-currency.pipe';\nimport {\n  LocalizedDatePipe,\n} from './localized-date.pipe';\nimport {\n  LocalizedDecimalPipe,\n} from './localized-decimal.pipe';\nimport {\n  TextDirectionService,\n} from './text-direction.service';\nimport {\n  TextDirectionality,\n} from './text-directionality.service';\n\n/**\n * creates LocalizationConfiguration, which is used if the application\n * @param configuration Localization configuration\n */\nexport function createLocalizationConfiguration(configuration?: Partial<LocalizationConfiguration>): LocalizationConfiguration {\n  return {\n    ...DEFAULT_LOCALIZATION_CONFIGURATION,\n    ...configuration\n  };\n}\n\n/**\n * Factory to inject the LOCALE_ID token with the current language into Angular context\n * @param localizationService Localization service\n */\nexport function localeIdNgBridge(localizationService: LocalizationService) {\n  return localizationService.getCurrentLanguage();\n}\n\n/** Custom Localization Configuration Token to override default localization configuration */\nexport const CUSTOM_LOCALIZATION_CONFIGURATION_TOKEN = new InjectionToken<Partial<LocalizationConfiguration>>('Partial Localization configuration');\n\n@NgModule({\n  declarations: [O3rLocalizationTranslatePipe, LocalizationTranslatePipe, LocalizationTranslateDirective, LocalizedDatePipe, LocalizedDecimalPipe, LocalizedCurrencyPipe],\n  imports: [TranslateModule, BidiModule, DynamicContentModule, CommonModule],\n  exports: [TranslateModule, O3rLocalizationTranslatePipe, LocalizationTranslatePipe, LocalizationTranslateDirective, LocalizedDatePipe, LocalizedDecimalPipe, LocalizedCurrencyPipe],\n  providers: [\n    { provide: LOCALIZATION_CONFIGURATION_TOKEN, useFactory: createLocalizationConfiguration, deps: [[new Optional(), CUSTOM_LOCALIZATION_CONFIGURATION_TOKEN]] },\n    { provide: LOCALE_ID, useFactory: localeIdNgBridge, deps: [LocalizationService] },\n    { provide: Directionality, useClass: TextDirectionality },\n    { provide: DatePipe, useClass: LocalizedDatePipe },\n    { provide: DecimalPipe, useClass: LocalizedDecimalPipe },\n    { provide: CurrencyPipe, useClass: LocalizedCurrencyPipe },\n    TextDirectionService\n  ]\n})\nexport class LocalizationModule {\n  /**\n   * forRoot method should be called only once from the application index.ts\n   * It will do several things:\n   * - provide the configuration for the whole application\n   * - register all locales specified in the LocalizationConfiguration\n   * - configure TranslateService\n   * - inject LOCALE_ID token\n   * @param configuration LocalizationConfiguration\n   */\n  public static forRoot(\n    configuration?: () => Partial<LocalizationConfiguration>\n  ): ModuleWithProviders<LocalizationModule> {\n    return {\n      ngModule: LocalizationModule,\n      providers: [\n        LocalizationService,\n        ...(configuration\n          ? [{\n            provide: CUSTOM_LOCALIZATION_CONFIGURATION_TOKEN,\n            useFactory: configuration\n          }]\n          : [])\n      ]\n    };\n  }\n}\n"]}

package/esm2022/tools/localization.provider.mjs

@@ -0,0 +1,25 @@
+import { Optional, } from '@angular/core';
+import { TranslateLoader, } from '@ngx-translate/core';
+import { DynamicContentService, } from '@o3r/dynamic-content';
+import { LoggerService, } from '@o3r/logger';
+import { LOCALIZATION_CONFIGURATION_TOKEN, } from './localization.token';
+import { TranslationsLoader, } from './translations-loader';
+/**
+ * Creates a loader of translations bundles based on the configuration
+ * (endPointUrl and language determine which bundle we load and where do we fetch it from)
+ * @param localizationConfiguration
+ * @param logger service to handle the log of warning and errors
+ * @param dynamicContentService (optional)
+ */
+export function createTranslateLoader(localizationConfiguration, logger, dynamicContentService) {
+    return new TranslationsLoader(localizationConfiguration, logger, dynamicContentService);
+}
+/**
+ * TranslateLoader provider, using framework's TranslationsLoader class
+ */
+export const translateLoaderProvider = {
+    provide: TranslateLoader,
+    useFactory: createTranslateLoader,
+    deps: [LOCALIZATION_CONFIGURATION_TOKEN, [new Optional(), LoggerService], [new Optional(), DynamicContentService]]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/tools/localization.service.mjs

@@ -0,0 +1,192 @@
+import { Inject, Injectable, Optional, } from '@angular/core';
+import { select, Store, } from '@ngrx/store';
+import { TranslateService, } from '@ngx-translate/core';
+import { LoggerService, } from '@o3r/logger';
+import { BehaviorSubject, combineLatest, of, } from 'rxjs';
+import { distinctUntilChanged, map, shareReplay, switchMap, } from 'rxjs/operators';
+import { selectLocalizationOverride, } from '../stores/index';
+import { LOCALIZATION_CONFIGURATION_TOKEN, } from './localization.token';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "@o3r/logger";
+import * as i3 from "@ngrx/store";
+/**
+ * Service which is wrapping the configuration logic of TranslateService from ngx-translate
+ * Any application willing to use localization just needs to inject LocalizationService
+ * in the root component and call its configure() method.
+ */
+export class LocalizationService {
+    constructor(translateService, logger, configuration, store) {
+        this.translateService = translateService;
+        this.logger = logger;
+        this.configuration = configuration;
+        this.store = store;
+        this.localeSplitIdentifier = '-';
+        /**
+         * Internal subject that we use to track changes between keys only and translation mode
+         */
+        this._showKeys$ = new BehaviorSubject(false);
+        /**
+         * _showKeys$ exposed as an Observable
+         */
+        this.showKeys$ = this._showKeys$.asObservable();
+        this.configure();
+        if (this.store) {
+            this.keyMapping$ = this.store.pipe(select(selectLocalizationOverride));
+        }
+    }
+    /**
+     * This will handle the fallback language hierarchy to find out fallback language.
+     * supportedLocales language has highest priority, next priority goes to fallbackLocalesMap and default would be
+     * fallbackLanguage.
+     * @param language Selected language.
+     * @returns selected language if supported, fallback language otherwise.
+     */
+    checkFallbackLocalesMap(language) {
+        if (language && !this.configuration.supportedLocales.includes(language)) {
+            const closestSupportedLanguageCode = this.getFirstClosestSupportedLanguageCode(language);
+            const fallbackForLanguage = this.getFallbackMapLangCode(language);
+            const fallbackStrategyDebug = (fallbackForLanguage && ' associated fallback language ')
+                || (closestSupportedLanguageCode && ' closest supported language ')
+                || (this.configuration.fallbackLanguage && ' configured default language ');
+            const fallbackLang = fallbackForLanguage || closestSupportedLanguageCode || this.configuration.fallbackLanguage || language;
+            if (language !== fallbackLang) {
+                this.logger.debug(`Non supported languages ${language} will fallback to ${fallbackStrategyDebug} ${fallbackLang}`);
+            }
+            return fallbackLang;
+        }
+        else if (!language) {
+            this.logger.debug('Language is not defined');
+        }
+        return language;
+    }
+    /**
+     * This function checks if fallback language can be provided from fallbackLocalesMap.
+     * supportedLocales: ['en-GB', 'en-US', 'fr-FR'], fallbackLocalesMap: {'en-CA': 'en-US', 'de': 'fr-FR'}
+     * translate to en-CA -> fallback to en-US, translate to de-DE -> fallback to fr-FR
+     * translate to en-NZ -> fallback to en-GB
+     * @param language Selected language.
+     * @returns Fallback language if available, undefined otherwise.
+     */
+    getFallbackMapLangCode(language) {
+        const fallbackLocalesMap = this.configuration.fallbackLocalesMap;
+        const [locale] = language.split(this.localeSplitIdentifier);
+        return fallbackLocalesMap && (fallbackLocalesMap[language] || fallbackLocalesMap[locale]);
+    }
+    /**
+     * This function checks if closest supported language available incase of selected language is not
+     * supported language.
+     * supportedLocales: ['en-GB', 'en-US', 'fr-FR']
+     * translate to en-CA -> fallback to en-GB
+     * @param language Selected language.
+     * @returns Closest supported language if available, undefined otherwise.
+     */
+    getFirstClosestSupportedLanguageCode(language) {
+        const [locale] = language.split(this.localeSplitIdentifier);
+        const firstClosestRegx = new RegExp(`^${locale}${this.localeSplitIdentifier}?`, 'i');
+        return this.configuration.supportedLocales.find((supportedLang) => firstClosestRegx.test(supportedLang));
+    }
+    /**
+     * Returns a stream of translated values of a key which updates whenever the language changes.
+     * @param translationKey Key to translate
+     * @param interpolateParams Object to use in translation binding
+     * @returns A stream of the translated key
+     */
+    getTranslationStream(translationKey, interpolateParams) {
+        const translation$ = this.translateService.stream(translationKey, interpolateParams).pipe(map((value) => this.configuration.debugMode ? `${translationKey} - ${value}` : value));
+        if (!this.configuration.enableTranslationDeactivation) {
+            return translation$;
+        }
+        return combineLatest([
+            translation$,
+            this.showKeys$
+        ]).pipe(map(([value, showKeys]) => showKeys ? translationKey : value));
+    }
+    /**
+     * Configures TranslateService and registers locales. This method is called from the application level.
+     */
+    configure() {
+        const language = this.checkFallbackLocalesMap(this.configuration.language || this.configuration.fallbackLanguage);
+        this.translateService.addLangs(this.configuration.supportedLocales);
+        this.translateService.setDefaultLang(language);
+        this.useLanguage(language);
+    }
+    /**
+     * Is the translation deactivation enabled
+     */
+    isTranslationDeactivationEnabled() {
+        return this.configuration.enableTranslationDeactivation;
+    }
+    /**
+     * Wrapper to call the ngx-translate service TranslateService method getLangs().
+     */
+    getLanguages() {
+        return this.translateService.getLangs();
+    }
+    /**
+     * Wrapper to call the ngx-translate service TranslateService method use(language).
+     * @param language
+     */
+    useLanguage(language) {
+        language = this.checkFallbackLocalesMap(language);
+        return this.translateService.use(language);
+    }
+    /**
+     * Wrapper to get the ngx-translate service TranslateService currentLang.
+     */
+    getCurrentLanguage() {
+        return this.translateService.currentLang;
+    }
+    /**
+     * Get the instance of the ngx-translate TranslateService used by LocalizationService.
+     */
+    getTranslateService() {
+        return this.translateService;
+    }
+    /**
+     * Toggle the ShowKeys mode between active and inactive.
+     * @param value if specified, set the ShowKeys mode to value. If not specified, toggle the ShowKeys mode.
+     */
+    toggleShowKeys(value) {
+        if (!this.configuration.enableTranslationDeactivation) {
+            throw new Error('Translation deactivation is not enabled. Please set the LocalizationConfiguration property "enableTranslationDeactivation" accordingly.');
+        }
+        const newValue = value === undefined ? !this.showKeys : value;
+        this._showKeys$.next(newValue);
+    }
+    /**
+     * Return the current value of debug show/hide translation keys.
+     */
+    get showKeys() {
+        return this._showKeys$.value;
+    }
+    /**
+     * Get an observable of translation key after global mapping
+     * @param requestedKey Original translation key
+     */
+    getKey(requestedKey) {
+        return this.keyMapping$
+            ? this.keyMapping$.pipe(map((keyMapping) => keyMapping?.[requestedKey] || requestedKey), distinctUntilChanged())
+            : of(requestedKey);
+    }
+    /**
+     * Returns a stream of translated values of a key which updates whenever the language changes.
+     * @param key Key to translate
+     * @param interpolateParams Object to use in translation binding
+     * @returns A stream of the translated key
+     */
+    translate(key, interpolateParams) {
+        return this.getKey(key).pipe(switchMap((translationKey) => this.getTranslationStream(translationKey, interpolateParams)), shareReplay({ refCount: true, bufferSize: 1 }));
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalizationService, deps: [{ token: i1.TranslateService }, { token: i2.LoggerService }, { token: LOCALIZATION_CONFIGURATION_TOKEN }, { token: i3.Store, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalizationService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalizationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.TranslateService }, { type: i2.LoggerService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCALIZATION_CONFIGURATION_TOKEN]
+                }] }, { type: i3.Store, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"localization.service.js","sourceRoot":"","sources":["../../../src/tools/localization.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Inject,\n  Injectable,\n  Optional,\n} from '@angular/core';\nimport {\n  select,\n  Store,\n} from '@ngrx/store';\nimport {\n  TranslateService,\n} from '@ngx-translate/core';\nimport {\n  LoggerService,\n} from '@o3r/logger';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  Observable,\n  of,\n} from 'rxjs';\nimport {\n  distinctUntilChanged,\n  map,\n  shareReplay,\n  switchMap,\n} from 'rxjs/operators';\nimport {\n  LocalizationConfiguration,\n} from '../core/localization.configuration';\nimport {\n  LocalizationOverrideStore,\n  selectLocalizationOverride,\n} from '../stores/index';\nimport {\n  LOCALIZATION_CONFIGURATION_TOKEN,\n} from './localization.token';\n\n/**\n * Service which is wrapping the configuration logic of TranslateService from ngx-translate\n * Any application willing to use localization just needs to inject LocalizationService\n * in the root component and call its configure() method.\n */\n@Injectable()\nexport class LocalizationService {\n  private readonly localeSplitIdentifier: string = '-';\n\n  /**\n   * Internal subject that we use to track changes between keys only and translation mode\n   */\n  private readonly _showKeys$ = new BehaviorSubject(false);\n\n  /**\n   * Map of localization keys to replace a key to another\n   */\n  private readonly keyMapping$?: Observable<Record<string, any>>;\n\n  /**\n   * _showKeys$ exposed as an Observable\n   */\n  public showKeys$ = this._showKeys$.asObservable();\n\n  constructor(\n    private readonly translateService: TranslateService,\n    private readonly logger: LoggerService,\n    @Inject(LOCALIZATION_CONFIGURATION_TOKEN) private readonly configuration: LocalizationConfiguration,\n    @Optional() private readonly store?: Store<LocalizationOverrideStore>\n  ) {\n    this.configure();\n    if (this.store) {\n      this.keyMapping$ = this.store.pipe(\n        select(selectLocalizationOverride)\n      );\n    }\n  }\n\n  /**\n   * This will handle the fallback language hierarchy to find out fallback language.\n   * supportedLocales language has highest priority, next priority goes to fallbackLocalesMap and default would be\n   * fallbackLanguage.\n   * @param language Selected language.\n   * @returns selected language if supported, fallback language otherwise.\n   */\n  private checkFallbackLocalesMap<T extends string | undefined>(language: T) {\n    if (language && !this.configuration.supportedLocales.includes(language)) {\n      const closestSupportedLanguageCode = this.getFirstClosestSupportedLanguageCode(language);\n      const fallbackForLanguage = this.getFallbackMapLangCode(language);\n      const fallbackStrategyDebug = (fallbackForLanguage && ' associated fallback language ')\n        || (closestSupportedLanguageCode && ' closest supported language ')\n        || (this.configuration.fallbackLanguage && ' configured default language ');\n      const fallbackLang = fallbackForLanguage || closestSupportedLanguageCode || this.configuration.fallbackLanguage || language;\n      if (language !== fallbackLang) {\n        this.logger.debug(`Non supported languages ${language} will fallback to ${fallbackStrategyDebug} ${fallbackLang}`);\n      }\n      return fallbackLang;\n    } else if (!language) {\n      this.logger.debug('Language is not defined');\n    }\n    return language;\n  }\n\n  /**\n   * This function checks if fallback language can be provided from fallbackLocalesMap.\n   * supportedLocales: ['en-GB', 'en-US', 'fr-FR'], fallbackLocalesMap: {'en-CA': 'en-US', 'de': 'fr-FR'}\n   * translate to en-CA -> fallback to en-US, translate to de-DE -> fallback to fr-FR\n   * translate to en-NZ -> fallback to en-GB\n   * @param language Selected language.\n   * @returns Fallback language if available, undefined otherwise.\n   */\n  private getFallbackMapLangCode(language: string): string | undefined {\n    const fallbackLocalesMap = this.configuration.fallbackLocalesMap;\n    const [locale] = language.split(this.localeSplitIdentifier);\n\n    return fallbackLocalesMap && (fallbackLocalesMap[language] || fallbackLocalesMap[locale]);\n  }\n\n  /**\n   * This function checks if closest supported language available incase of selected language is not\n   * supported language.\n   * supportedLocales: ['en-GB', 'en-US', 'fr-FR']\n   * translate to en-CA -> fallback to en-GB\n   * @param language Selected language.\n   * @returns Closest supported language if available, undefined otherwise.\n   */\n  private getFirstClosestSupportedLanguageCode(language: string): string | undefined {\n    const [locale] = language.split(this.localeSplitIdentifier);\n    const firstClosestRegx = new RegExp(`^${locale}${this.localeSplitIdentifier}?`, 'i');\n\n    return this.configuration.supportedLocales.find((supportedLang) => firstClosestRegx.test(supportedLang));\n  }\n\n  /**\n   * Returns a stream of translated values of a key which updates whenever the language changes.\n   * @param translationKey Key to translate\n   * @param interpolateParams Object to use in translation binding\n   * @returns A stream of the translated key\n   */\n  private getTranslationStream(translationKey: string, interpolateParams?: object) {\n    const translation$ = this.translateService.stream(translationKey, interpolateParams).pipe(\n      map((value: string) => this.configuration.debugMode ? `${translationKey} - ${value}` : value)\n    );\n\n    if (!this.configuration.enableTranslationDeactivation) {\n      return translation$;\n    }\n\n    return combineLatest([\n      translation$,\n      this.showKeys$\n    ]).pipe(\n      map(([value, showKeys]) => showKeys ? translationKey : value)\n    );\n  }\n\n  /**\n   * Configures TranslateService and registers locales. This method is called from the application level.\n   */\n  public configure() {\n    const language = this.checkFallbackLocalesMap(this.configuration.language || this.configuration.fallbackLanguage);\n    this.translateService.addLangs(this.configuration.supportedLocales);\n    this.translateService.setDefaultLang(language);\n    this.useLanguage(language);\n  }\n\n  /**\n   * Is the translation deactivation enabled\n   */\n  public isTranslationDeactivationEnabled() {\n    return this.configuration.enableTranslationDeactivation;\n  }\n\n  /**\n   * Wrapper to call the ngx-translate service TranslateService method getLangs().\n   */\n  public getLanguages() {\n    return this.translateService.getLangs();\n  }\n\n  /**\n   * Wrapper to call the ngx-translate service TranslateService method use(language).\n   * @param language\n   */\n  public useLanguage(language: string): Observable<any> {\n    language = this.checkFallbackLocalesMap(language);\n    return this.translateService.use(language);\n  }\n\n  /**\n   * Wrapper to get the ngx-translate service TranslateService currentLang.\n   */\n  public getCurrentLanguage() {\n    return this.translateService.currentLang;\n  }\n\n  /**\n   * Get the instance of the ngx-translate TranslateService used by LocalizationService.\n   */\n  public getTranslateService() {\n    return this.translateService;\n  }\n\n  /**\n   * Toggle the ShowKeys mode between active and inactive.\n   * @param value if specified, set the ShowKeys mode to value. If not specified, toggle the ShowKeys mode.\n   */\n  public toggleShowKeys(value?: boolean) {\n    if (!this.configuration.enableTranslationDeactivation) {\n      throw new Error('Translation deactivation is not enabled. Please set the LocalizationConfiguration property \"enableTranslationDeactivation\" accordingly.');\n    }\n    const newValue = value === undefined ? !this.showKeys : value;\n    this._showKeys$.next(newValue);\n  }\n\n  /**\n   * Return the current value of debug show/hide translation keys.\n   */\n  public get showKeys() {\n    return this._showKeys$.value;\n  }\n\n  /**\n   * Get an observable of translation key after global mapping\n   * @param requestedKey Original translation key\n   */\n  public getKey(requestedKey: string) {\n    return this.keyMapping$\n      ? this.keyMapping$.pipe(\n        map((keyMapping) => keyMapping?.[requestedKey] || requestedKey),\n        distinctUntilChanged()\n      )\n      : of(requestedKey);\n  }\n\n  /**\n   * Returns a stream of translated values of a key which updates whenever the language changes.\n   * @param key Key to translate\n   * @param interpolateParams Object to use in translation binding\n   * @returns A stream of the translated key\n   */\n  public translate(key: string, interpolateParams?: object) {\n    return this.getKey(key).pipe(\n      switchMap((translationKey) => this.getTranslationStream(translationKey, interpolateParams)),\n      shareReplay({ refCount: true, bufferSize: 1 })\n    );\n  }\n}\n"]}

package/esm2022/tools/localization.token.mjs

@@ -0,0 +1,4 @@
+import { InjectionToken, } from '@angular/core';
+/** Localization Configuration Token */
+export const LOCALIZATION_CONFIGURATION_TOKEN = new InjectionToken('Localization Configuration injection token');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWxpemF0aW9uLnRva2VuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Rvb2xzL2xvY2FsaXphdGlvbi50b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsY0FBYyxHQUNmLE1BQU0sZUFBZSxDQUFDO0FBS3ZCLHVDQUF1QztBQUN2QyxNQUFNLENBQUMsTUFBTSxnQ0FBZ0MsR0FBRyxJQUFJLGNBQWMsQ0FBNEIsNENBQTRDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIEluamVjdGlvblRva2VuLFxufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7XG4gIExvY2FsaXphdGlvbkNvbmZpZ3VyYXRpb24sXG59IGZyb20gJy4uL2NvcmUnO1xuXG4vKiogTG9jYWxpemF0aW9uIENvbmZpZ3VyYXRpb24gVG9rZW4gKi9cbmV4cG9ydCBjb25zdCBMT0NBTElaQVRJT05fQ09ORklHVVJBVElPTl9UT0tFTiA9IG5ldyBJbmplY3Rpb25Ub2tlbjxMb2NhbGl6YXRpb25Db25maWd1cmF0aW9uPignTG9jYWxpemF0aW9uIENvbmZpZ3VyYXRpb24gaW5qZWN0aW9uIHRva2VuJyk7XG4iXX0=

package/esm2022/tools/localized-currency.pipe.mjs

@@ -0,0 +1,32 @@
+import { CurrencyPipe, } from '@angular/common';
+import { ChangeDetectorRef, Pipe, } from '@angular/core';
+import { LocalizationService, } from './localization.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./localization.service";
+/**
+ * Native angular CurrencyPipe taking the current lang into consideration
+ */
+export class LocalizedCurrencyPipe extends CurrencyPipe {
+    constructor(localizationService, changeDetectorRef) {
+        super(localizationService.getCurrentLanguage());
+        this.localizationService = localizationService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.onLangChange = this.localizationService.getTranslateService().onLangChange.subscribe(() => this.changeDetectorRef.markForCheck());
+    }
+    transform(value, currencyCode, display, digitsInfo, locale) {
+        return super.transform(value, currencyCode, display, digitsInfo, locale || this.localizationService.getCurrentLanguage());
+    }
+    ngOnDestroy() {
+        this.onLangChange.unsubscribe();
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalizedCurrencyPipe, deps: [{ token: i1.LocalizationService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    /** @nocollapse */ static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: LocalizedCurrencyPipe, name: "currency", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LocalizedCurrencyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'currency',
+                    pure: false
+                }]
+        }], ctorParameters: () => [{ type: i1.LocalizationService }, { type: i0.ChangeDetectorRef }] });
+//# sourceMappingURL=data:application/json;base64,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