@o3r/transloco 0.0.0 → 14.4.0-rc.0

package/fesm2022/o3r-transloco.mjs

@@ -0,0 +1,1177 @@
+import { immutablePrimitive, deepFill, otterComponentInfoPropertyName, sendOtterMessage, filterMessageContent } from '@o3r/core';
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injectable, Injector, Optional, NgModule, signal, ChangeDetectorRef, Pipe, RendererFactory2, LOCALE_ID, isDevMode, makeEnvironmentProviders, ElementRef, Renderer2, TemplateRef, DestroyRef, SimpleChange, Input, Directive, ApplicationRef } from '@angular/core';
+import { TRANSLOCO_LOADER, TranslocoService, provideTransloco, TranslocoDirective, TranslocoPipe, TRANSLOCO_SCOPE, TRANSLOCO_LANG, TRANSLOCO_TRANSPILER } from '@jsverse/transloco';
+import { from, of, combineLatest, startWith, switchMap as switchMap$1, map as map$1, distinctUntilChanged, firstValueFrom, shareReplay, Subject, lastValueFrom, fromEvent } from 'rxjs';
+import { DynamicContentService } from '@o3r/dynamic-content';
+import { LoggerService } from '@o3r/logger';
+import { switchMap, catchError, map } from 'rxjs/operators';
+import { CurrencyPipe, DatePipe, DecimalPipe } from '@angular/common';
+import { toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i1 from '@ngrx/store';
+import { createAction, props, on, createReducer, StoreModule, createFeatureSelector, createSelector, Store, select } from '@ngrx/store';
+import { Directionality } from '@angular/cdk/bidi';
+
+/**
+ * Decorator to pass localization url
+ * @param url
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention -- decorator should start with a capital letter
+function Localization(url) {
+    return (target, key) => {
+        const privateField = url || `_${key}`;
+        const privateValue = target[key];
+        if (delete target[key]) {
+            Object.defineProperty(target, key, {
+                get: function () {
+                    return this[privateField];
+                },
+                set: function (value) {
+                    const currentField = this[privateField] || privateValue;
+                    this[privateField] = typeof currentField === 'undefined' ? immutablePrimitive(value) : deepFill(currentField, value);
+                    if (this[otterComponentInfoPropertyName]) {
+                        this[otterComponentInfoPropertyName].translations = this[privateField];
+                    }
+                },
+                enumerable: true,
+                configurable: true
+            });
+        }
+    };
+}
+
+/**
+ * Default configuration for LocalizationModule
+ */
+const DEFAULT_LOCALIZATION_CONFIGURATION = {
+    supportedLocales: [],
+    endPointUrl: '',
+    useDynamicContent: false,
+    rtlLanguages: ['ar', 'he'],
+    fallbackLanguage: 'en',
+    bundlesOutputPath: '',
+    debugMode: false,
+    enableTranslationDeactivation: false,
+    mergeWithLocalTranslations: false
+};
+
+/**
+ * Formats a debug key string combining the translation key and its value.
+ * Used across the localization service, pipe, and directive when debugMode is enabled.
+ * @param key The translation key
+ * @param value The translated value
+ */
+function getDebugKey(key, value) {
+    return `${key} - ${value}`;
+}
+
+/** Localization Configuration Token */
+const LOCALIZATION_CONFIGURATION_TOKEN = new InjectionToken('Localization Configuration injection token');
+
+const JSON_EXT = '.json';
+/**
+ * This class is responsible for loading translation bundles from remote or local endpoints depending on the LocalizationConfiguration.
+ * Fallback mechanism ensures that if a bundle in some language cannot be fetched remotely
+ * we try to fetch the same language bundle locally (bundles stored inside the application)
+ * and finally load the fallback language bundle (if all previous fetches failed)
+ */
+class TranslationsLoader {
+    constructor() {
+        this.localizationConfiguration = inject(LOCALIZATION_CONFIGURATION_TOKEN);
+        this.logger = inject(LoggerService, { optional: true });
+        this.dynamicContentService = inject(DynamicContentService, { optional: true });
+    }
+    /**
+     * Download a language bundle file
+     * @param  url Url to the bundle file
+     */
+    downloadLanguageBundle$(url) {
+        const queryParams = this.localizationConfiguration.queryParams;
+        const parsedUrl = new URL(url, window.location.origin);
+        if (queryParams) {
+            Object.entries(queryParams).forEach(([key, value]) => parsedUrl.searchParams.append(key, value));
+        }
+        return from(fetch(parsedUrl.href, this.localizationConfiguration.fetchOptions)).pipe(switchMap((response) => response.json()));
+    }
+    /**
+     * @inheritdoc
+     */
+    getTranslation(lang) {
+        const fallback = this.localizationConfiguration.fallbackLanguage;
+        let localizationPath$ = of(this.localizationConfiguration.endPointUrl);
+        if (this.localizationConfiguration.useDynamicContent) {
+            if (!this.dynamicContentService) {
+                throw new Error('Dynamic Content is not available. Please verify you have provided the DynamicContent in your application');
+            }
+            localizationPath$ = this.dynamicContentService.getContentPathStream(this.localizationConfiguration.endPointUrl);
+        }
+        return localizationPath$.pipe(switchMap((localizationPath) => {
+            if (localizationPath) {
+                const localizationBundle$ = this.downloadLanguageBundle$(localizationPath + lang + JSON_EXT);
+                if (this.localizationConfiguration.mergeWithLocalTranslations) {
+                    return combineLatest([
+                        localizationBundle$.pipe(catchError(() => {
+                            this.logger?.warn(`Failed to load the localization resource from ${localizationPath + lang + JSON_EXT} during merge, falling back to local translations only`);
+                            return of({});
+                        })),
+                        this.getTranslationFromLocal(lang, fallback).pipe(map((translations) => {
+                            Object.entries(translations).forEach(([key, value]) => translations[key] = `[local] ${value}`);
+                            return translations;
+                        }))
+                    ]).pipe(map(([dynamicTranslations, localTranslations]) => ({ ...localTranslations, ...dynamicTranslations })));
+                }
+                /*
+                * if endPointUrl is specified by the configuration then:
+                *   1. try to load lang from endPointUrl
+                *   2. if 1 fails then try to load from the app (local file)
+                */
+                return localizationBundle$.pipe(catchError(() => {
+                    this.logger?.warn(`Failed to load the localization resource from ${localizationPath + lang + JSON_EXT}, trying from the application resources`);
+                    return this.getTranslationFromLocal(lang, fallback);
+                }));
+            }
+            /*
+            * else if endPointUrl NOT specified by then configuration then:
+            *   1. try to load from the app (local file)
+            */
+            this.logger?.warn('No localization endpoint specified, localization fetch from application resources');
+            return this.getTranslationFromLocal(lang, fallback);
+        }));
+    }
+    /**
+     *
+     *Fetches localization bundles from published folder (internal to application)
+     *
+     *1. try to load lang from local
+     *2. if 1 fails try to load fallback lang but only if it's different from lang in 1
+     * @param lang - language of the bundle
+     * @param fallbackLanguage - fallback language in case bundle in language not found
+     */
+    getTranslationFromLocal(lang, fallbackLanguage) {
+        const pathPrefix = this.localizationConfiguration.bundlesOutputPath;
+        return this.downloadLanguageBundle$(pathPrefix + lang + JSON_EXT).pipe(catchError(() => {
+            if (lang === fallbackLanguage) {
+                this.logger?.error(`Failed to load ${lang} from ${pathPrefix + lang + JSON_EXT}.`);
+                return of({});
+            }
+            else {
+                this.logger?.warn(`Failed to load ${lang} from ${pathPrefix + lang + JSON_EXT}. Application will fallback to ${fallbackLanguage}`);
+                return this.getTranslationFromLocal(fallbackLanguage, fallbackLanguage);
+            }
+        }));
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: TranslationsLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: TranslationsLoader }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: TranslationsLoader, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * 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)
+ */
+function createTranslateLoader(localizationConfiguration, logger, dynamicContentService) {
+    const injector = Injector.create({
+        providers: [
+            { provide: LOCALIZATION_CONFIGURATION_TOKEN, useValue: localizationConfiguration },
+            { provide: LoggerService, useValue: logger },
+            { provide: DynamicContentService, useValue: dynamicContentService },
+            {
+                provide: TranslationsLoader,
+                deps: [[LoggerService, new Optional()], [DynamicContentService, new Optional()], LOCALIZATION_CONFIGURATION_TOKEN]
+            }
+        ]
+    });
+    return injector.get(TranslationsLoader);
+}
+/**
+ * TranslocoLoader provider, using framework's TranslationsLoader class
+ */
+const translateLoaderProvider = {
+    provide: TRANSLOCO_LOADER,
+    useFactory: createTranslateLoader,
+    deps: [LOCALIZATION_CONFIGURATION_TOKEN, [new Optional(), LoggerService], [new Optional(), DynamicContentService]]
+};
+
+/** Actions */
+const ACTION_SET = '[LocalizationOverride] set';
+/**
+ * Clear all overrides and fill the store with the payload
+ */
+const setLocalizationOverride = createAction(ACTION_SET, props());
+
+/**
+ * LocalizationOverride Store initial value
+ */
+const localizationOverrideInitialState = { localizationOverrides: {} };
+/**
+ *  List of basic actions for LocalizationOverride Store
+ */
+const localizationOverrideReducerFeatures = [
+    on(setLocalizationOverride, (_state, payload) => ({ ...payload.state }))
+];
+/**
+ * LocalizationOverride Store reducer
+ */
+const localizationOverrideReducer = createReducer(localizationOverrideInitialState, ...localizationOverrideReducerFeatures);
+
+/**
+ * Name of the LocalizationOverride Store
+ */
+const LOCALIZATION_OVERRIDE_STORE_NAME = 'localizationOverride';
+
+/** Token of the LocalizationOverride reducer */
+const LOCALIZATION_OVERRIDE_REDUCER_TOKEN = new InjectionToken('Feature LocalizationOverride Reducer');
+/** Provide default reducer for LocalizationOverride store */
+function getDefaultLocalizationOverrideReducer() {
+    return localizationOverrideReducer;
+}
+/**
+ * NgModule for localization override store.
+ */
+class LocalizationOverrideStoreModule {
+    static forRoot(reducerFactory) {
+        return {
+            ngModule: LocalizationOverrideStoreModule,
+            providers: [
+                { provide: LOCALIZATION_OVERRIDE_REDUCER_TOKEN, useFactory: reducerFactory }
+            ]
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizationOverrideStoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.15", ngImport: i0, type: LocalizationOverrideStoreModule, imports: [i1.StoreFeatureModule] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizationOverrideStoreModule, providers: [
+            { provide: LOCALIZATION_OVERRIDE_REDUCER_TOKEN, useFactory: getDefaultLocalizationOverrideReducer }
+        ], imports: [StoreModule.forFeature(LOCALIZATION_OVERRIDE_STORE_NAME, LOCALIZATION_OVERRIDE_REDUCER_TOKEN)] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizationOverrideStoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        StoreModule.forFeature(LOCALIZATION_OVERRIDE_STORE_NAME, LOCALIZATION_OVERRIDE_REDUCER_TOKEN)
+                    ],
+                    providers: [
+                        { provide: LOCALIZATION_OVERRIDE_REDUCER_TOKEN, useFactory: getDefaultLocalizationOverrideReducer }
+                    ]
+                }]
+        }] });
+
+/** Select LocalizationOverride State */
+const selectLocalizationOverrideState = createFeatureSelector(LOCALIZATION_OVERRIDE_STORE_NAME);
+/** Select all localization override map */
+const selectLocalizationOverride = createSelector(selectLocalizationOverrideState, (state) => state?.localizationOverrides || {});
+
+/**
+ * Deserializer for the LocalizationOverride store storage
+ * @param rawObject
+ */
+const localizationOverrideStorageDeserializer = (rawObject) => {
+    if (!rawObject) {
+        return localizationOverrideInitialState;
+    }
+    return rawObject;
+};
+/** Serializer/Deserializer configuration for the LocalizationOverride store sync */
+const localizationOverrideStorageSync = {
+    deserialize: localizationOverrideStorageDeserializer
+};
+
+/**
+ * Service which is wrapping the configuration logic of TranslocoService from JSVerse Transloco.
+ * Any application willing to use localization just needs to inject LocalizationService
+ * in the root component and call its configure() method.
+ */
+class LocalizationService {
+    constructor() {
+        this.translateService = inject(TranslocoService);
+        this.logger = inject(LoggerService, { optional: true });
+        this.configuration = inject(LOCALIZATION_CONFIGURATION_TOKEN);
+        this.store = inject(Store, { optional: true });
+        this.localeSplitIdentifier = '-';
+        /**
+         * Internal signal that we use to track changes between keys only and translation mode
+         */
+        this._showKeys = signal(false, ...(ngDevMode ? [{ debugName: "_showKeys" }] : /* istanbul ignore next */ []));
+        /**
+         * _showKeys exposed as an Observable
+         */
+        this.showKeys$ = toObservable(this._showKeys);
+        /**
+         * Return the current value of debug show/hide translation keys.
+         */
+        this.showKeys = this._showKeys.asReadonly();
+        this.configure().catch((err) => {
+            this.logger?.error(`Failed to configure LocalizationService: ${err}`);
+        });
+        if (this.store) {
+            this.keyMapping$ = this.store.pipe(select(selectLocalizationOverride));
+        }
+        else {
+            this.logger?.debug('Store not available: localization key overrides via rules engine will not be active.');
+        }
+    }
+    /**
+     * 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.events$.pipe(startWith(undefined), switchMap$1(() => this.translateService.selectTranslate(translationKey, interpolateParams)), map$1((value) => this.configuration.debugMode ? getDebugKey(translationKey, value) : value), distinctUntilChanged());
+        if (!this.configuration.enableTranslationDeactivation) {
+            return translation$;
+        }
+        return combineLatest([
+            translation$,
+            this.showKeys$
+        ]).pipe(map$1(([value, showKeys]) => showKeys ? translationKey : value));
+    }
+    /**
+     * Configures TranslocoService and registers locales. This method is called from the application level.
+     */
+    async configure() {
+        const language = this.checkFallbackLocalesMap(this.configuration.language || this.configuration.fallbackLanguage);
+        this.translateService.setAvailableLangs(this.configuration.supportedLocales);
+        this.translateService.setDefaultLang(language);
+        await firstValueFrom(this.useLanguage(language));
+    }
+    /**
+     * Is the translation deactivation enabled
+     */
+    isTranslationDeactivationEnabled() {
+        return this.configuration.enableTranslationDeactivation;
+    }
+    /**
+     * Wrapper to call the TranslocoService method getAvailableLangs().
+     */
+    getLanguages() {
+        return this.translateService.getAvailableLangs().map((l) => (typeof l === 'string' ? l : l.id));
+    }
+    /**
+     * Wrapper to call the TranslocoService method setActiveLang(language).
+     * @param language
+     */
+    useLanguage(language) {
+        language = this.checkFallbackLocalesMap(language);
+        this.translateService.setActiveLang(language);
+        return this.translateService.load(language);
+    }
+    /**
+     * Wrapper to get the TranslocoService getActiveLang.
+     */
+    getCurrentLanguage() {
+        return this.translateService.getActiveLang();
+    }
+    /**
+     * Get the instance of the TranslocoService 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.set(newValue);
+    }
+    /**
+     * Get an observable of translation key after global mapping
+     * @param requestedKey Original translation key
+     */
+    getKey(requestedKey) {
+        return this.keyMapping$
+            ? this.keyMapping$.pipe(map$1((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$1((translationKey) => this.getTranslationStream(translationKey, interpolateParams)), shareReplay({ refCount: true, bufferSize: 1 }));
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizationService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+/**
+ * Native angular CurrencyPipe taking the current lang into consideration
+ */
+class LocalizedCurrencyPipe extends CurrencyPipe {
+    constructor() {
+        super(inject(LocalizationService).getCurrentLanguage());
+        this.localizationService = inject(LocalizationService);
+        this.changeDetectorRef = inject(ChangeDetectorRef);
+        this.localizationService.getTranslateService().langChanges$
+            .pipe(takeUntilDestroyed())
+            .subscribe(() => this.changeDetectorRef.markForCheck());
+    }
+    transform(value, currencyCode, display, digitsInfo, locale) {
+        return this.localizationService.showKeys() ? '' : super.transform(value, currencyCode, display, digitsInfo, locale || this.localizationService.getCurrentLanguage());
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizedCurrencyPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    /** @nocollapse */ static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.15", ngImport: i0, type: LocalizedCurrencyPipe, isStandalone: true, name: "currency", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizedCurrencyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'currency',
+                    pure: false,
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Native angular DatePipe taking the current lang into consideration
+ */
+class LocalizedDatePipe extends DatePipe {
+    constructor() {
+        super(inject(LocalizationService).getCurrentLanguage());
+        this.localizationService = inject(LocalizationService);
+        this.changeDetectorRef = inject(ChangeDetectorRef);
+        this.localizationService.getTranslateService().langChanges$
+            .pipe(takeUntilDestroyed())
+            .subscribe(() => this.changeDetectorRef.markForCheck());
+    }
+    transform(value, format = 'mediumDate', timezone, locale) {
+        return this.localizationService.showKeys() ? format : super.transform(value, format, timezone, locale || this.localizationService.getCurrentLanguage());
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizedDatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    /** @nocollapse */ static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.15", ngImport: i0, type: LocalizedDatePipe, isStandalone: true, name: "date", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizedDatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'date',
+                    pure: false,
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Native angular DecimalPipe taking the current lang into consideration
+ */
+class LocalizedDecimalPipe extends DecimalPipe {
+    constructor() {
+        super(inject(LocalizationService).getCurrentLanguage());
+        this.localizationService = inject(LocalizationService);
+        this.changeDetectorRef = inject(ChangeDetectorRef);
+        this.localizationService.getTranslateService().langChanges$
+            .pipe(takeUntilDestroyed())
+            .subscribe(() => this.changeDetectorRef.markForCheck());
+    }
+    transform(value, digitsInfo, locale) {
+        return this.localizationService.showKeys() ? '' : super.transform(value, digitsInfo, locale || this.localizationService.getCurrentLanguage());
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizedDecimalPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    /** @nocollapse */ static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.15", ngImport: i0, type: LocalizedDecimalPipe, isStandalone: true, name: "number", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizedDecimalPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'number',
+                    pure: false,
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Service for handling the text direction based on the LocalizationConfiguration
+ */
+class TextDirectionService {
+    constructor() {
+        this.translateService = inject(TranslocoService);
+        this.configuration = inject(LOCALIZATION_CONFIGURATION_TOKEN);
+        this.rendererFactory = inject(RendererFactory2);
+        this.directionality = inject(Directionality);
+        this.renderer = this.rendererFactory.createRenderer(null, null);
+    }
+    /**
+     * Updates the dir attribute on body HTML tag.
+     * @returns a subscription that updates the dir attribute
+     */
+    onLangChangeSubscription() {
+        if (this.subscription && !this.subscription.closed) {
+            return this.subscription;
+        }
+        this.subscription = this.translateService.langChanges$.subscribe((lang) => {
+            const direction = this.configuration.rtlLanguages.includes(lang.split('-')[0]) ? 'rtl' : 'ltr';
+            this.renderer.setAttribute(document.body, 'dir', direction);
+            this.directionality.change.emit(direction);
+        });
+        return this.subscription;
+    }
+    ngOnDestroy() {
+        this.subscription?.unsubscribe();
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: TextDirectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: TextDirectionService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: TextDirectionService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+/**
+ * creates LocalizationConfiguration, which is used if the application
+ * @param configuration Localization configuration
+ */
+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
+ */
+function localeIdNgBridge(localizationService) {
+    return localizationService.getCurrentLanguage();
+}
+/** Custom Localization Configuration Token to override default localization configuration */
+const CUSTOM_LOCALIZATION_CONFIGURATION_TOKEN = new InjectionToken('Partial Localization configuration');
+/**
+ * Provide localization services and configuration for the application.
+ * This is the recommended way to set up localization in standalone applications.
+ * @param configuration Optional partial localization configuration to override defaults. Can be a configuration object or a factory function.
+ * @example Override of default and supported languages override at application bootstrap
+ * ```typescript
+ * bootstrapApplication(App, {
+ *   providers: [
+ *     provideLocalization({ language: 'en-US', supportedLocales: ['en-US', 'fr-FR'] })
+ *   ]
+ * });
+ * ```
+ */
+function provideLocalization(configuration) {
+    const config = typeof configuration === 'function' ? configuration() : (configuration || {});
+    const mergedConfig = { ...DEFAULT_LOCALIZATION_CONFIGURATION, ...config };
+    const providers = [
+        provideTransloco({
+            config: {
+                availableLangs: mergedConfig.supportedLocales || [],
+                defaultLang: mergedConfig.language || mergedConfig.fallbackLanguage,
+                reRenderOnLangChange: true,
+                prodMode: !isDevMode(),
+                fallbackLang: mergedConfig.fallbackLanguage,
+                missingHandler: {
+                    useFallbackTranslation: true
+                }
+            }
+        }),
+        translateLoaderProvider,
+        LocalizationService,
+        TextDirectionService,
+        { provide: LOCALIZATION_CONFIGURATION_TOKEN, useFactory: createLocalizationConfiguration, deps: [[new Optional(), CUSTOM_LOCALIZATION_CONFIGURATION_TOKEN]] },
+        { provide: LOCALE_ID, useFactory: localeIdNgBridge, deps: [LocalizationService] },
+        { provide: DatePipe, useClass: LocalizedDatePipe },
+        { provide: DecimalPipe, useClass: LocalizedDecimalPipe },
+        { provide: CurrencyPipe, useClass: LocalizedCurrencyPipe }
+    ];
+    if (configuration) {
+        providers.push({
+            provide: CUSTOM_LOCALIZATION_CONFIGURATION_TOKEN,
+            ...(typeof configuration === 'function' ? { useFactory: configuration } : { useValue: configuration })
+        });
+    }
+    return makeEnvironmentProviders(providers);
+}
+
+/**
+ * TranslocoDirective class adding debug functionality.
+ *
+ * Extends the TranslocoDirective from Transloco to add:
+ * - Key mapping via LocalizationService (override store)
+ * - Show keys mode (display raw keys instead of translations)
+ * - Debug mode (display key alongside translation)
+ *
+ * For the structural strategy (`*transloco`), the debug/showKeys behavior is handled
+ * by overriding `getTranslateFn`.
+ *
+ * For the attribute strategy (`[transloco]="key"`), the parent's private `attributeStrategy()`
+ * sets `innerText` directly. Since we cannot override this private method, we apply
+ * debug/showKeys transformations by overwriting `innerText` immediately after calling
+ * `super.ngOnInit()` and `super.ngOnChanges()`, in the same call stack.
+ */
+class LocalizationTranslateDirective extends TranslocoDirective {
+    /** @inheritdoc */
+    set transloco(key) {
+        if (key) {
+            this.translocoSubject.next(key);
+        }
+    }
+    constructor() {
+        super();
+        this.localizationService = inject(LocalizationService);
+        this.localizationConfig = inject(LOCALIZATION_CONFIGURATION_TOKEN);
+        this.changeDetectorRef = inject(ChangeDetectorRef);
+        this.hostElement = inject(ElementRef);
+        this.hostRenderer = inject(Renderer2);
+        this.isAttributeStrategy = inject(TemplateRef, { optional: true }) === null;
+        this.o3rDestroyRef = inject(DestroyRef);
+        /**
+         * Should we display keys instead of translations
+         */
+        this.showKeys = false;
+        /**
+         * Subject to emit translation key changes
+         */
+        this.translocoSubject = new Subject();
+        if (this.localizationConfig.enableTranslationDeactivation) {
+            this.localizationService.showKeys$.pipe(takeUntilDestroyed(this.o3rDestroyRef)).subscribe((showKeys) => {
+                this.showKeys = showKeys;
+                this.changeDetectorRef.markForCheck();
+            });
+        }
+        // Set up reactive key mapping subscription
+        this.translocoSubject.pipe(switchMap$1((key) => this.localizationService.getKey(key)), takeUntilDestroyed(this.o3rDestroyRef)).subscribe((newKey) => {
+            const previousKey = this.key;
+            this.key = newKey;
+            this.changeDetectorRef.markForCheck();
+            super.ngOnChanges({ transloco: new SimpleChange(previousKey, newKey, !previousKey) });
+        });
+    }
+    /**
+     * For the attribute strategy, overwrites `innerText` with the debug/showKeys value
+     * immediately after the parent has set it.
+     */
+    applyAttributeDebug() {
+        if (!this.isAttributeStrategy || !this.key) {
+            return;
+        }
+        if (this.showKeys) {
+            this.hostRenderer.setProperty(this.hostElement.nativeElement, 'innerText', this.key);
+        }
+        else if (this.localizationConfig.debugMode) {
+            this.hostRenderer.setProperty(this.hostElement.nativeElement, 'innerText', getDebugKey(this.key, this.hostElement.nativeElement.innerText));
+        }
+    }
+    /**
+     * Override getTranslateFn to plug debug/showKeys for the structural strategy.
+     * @param lang Current language
+     * @param prefix Scope prefix
+     */
+    getTranslateFn(lang, prefix) {
+        const parentTranslateFn = super.getTranslateFn(lang, prefix);
+        return (key, params) => {
+            if (this.showKeys) {
+                return key;
+            }
+            const value = parentTranslateFn(key, params);
+            if (this.localizationConfig.debugMode) {
+                return getDebugKey(key, value);
+            }
+            return value;
+        };
+    }
+    /** @inheritdoc */
+    ngOnInit() {
+        super.ngOnInit();
+        this.applyAttributeDebug();
+    }
+    /** @inheritdoc */
+    ngOnChanges(changes) {
+        super.ngOnChanges(changes);
+        this.applyAttributeDebug();
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizationTranslateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.15", type: LocalizationTranslateDirective, isStandalone: true, selector: "[transloco]", inputs: { transloco: "transloco" }, usesInheritance: true, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizationTranslateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[transloco]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [], propDecorators: { transloco: [{
+                type: Input
+            }] } });
+
+/**
+ * TranslocoPipe class adding debug functionality
+ */
+class O3rLocalizationTranslatePipe extends TranslocoPipe {
+    constructor() {
+        super(inject(TranslocoService), inject(TRANSLOCO_SCOPE, { optional: true }) ?? undefined, inject(TRANSLOCO_LANG, { optional: true }) ?? undefined, inject(ChangeDetectorRef));
+        /** Localization service instance */
+        this.localizationService = inject(LocalizationService);
+        /** Change detector service instance */
+        this.changeDetector = inject(ChangeDetectorRef);
+        /** Localization config token */
+        this.localizationConfig = inject(LOCALIZATION_CONFIGURATION_TOKEN);
+        /** Destroy reference */
+        this.destroyRef = inject(DestroyRef);
+        /**
+         * Should we display keys instead of translations
+         */
+        this.showKeys = false;
+        /**
+         * Subject to emit translation key changes
+         */
+        this.querySubject = new Subject();
+        if (this.localizationConfig.enableTranslationDeactivation) {
+            this.localizationService.showKeys$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((showKeys) => {
+                this.showKeys = showKeys;
+                this.changeDetector.markForCheck();
+            });
+        }
+        // Set up reactive key mapping subscription
+        this.querySubject.pipe(switchMap$1((query) => this.localizationService.getKey(query)), takeUntilDestroyed(this.destroyRef)).subscribe((key) => {
+            this.lastResolvedKey = key;
+            this.changeDetector.markForCheck();
+        });
+    }
+    /**
+     * Calls original transform method and eventually outputs the key if debugMode (in LocalizationConfiguration) is enabled
+     * @inheritdoc
+     */
+    transform(query, ...args) {
+        if (!query || this.localizationService.showKeys()) {
+            return query;
+        }
+        // Emit query to subject for reactive key mapping
+        this.querySubject.next(query);
+        const value = super.transform(this.lastResolvedKey, ...args);
+        if (this.localizationConfig.debugMode) {
+            return getDebugKey(this.lastResolvedKey, value);
+        }
+        return value;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: O3rLocalizationTranslatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    /** @nocollapse */ static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.15", ngImport: i0, type: O3rLocalizationTranslatePipe, isStandalone: true, name: "o3rTranslate", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: O3rLocalizationTranslatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'o3rTranslate',
+                    pure: false,
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Service that provides core localization devtools functionality
+ */
+class OtterLocalizationDevtools {
+    constructor() {
+        this.localizationService = inject(LocalizationService);
+        this.translateTranspiler = inject(TRANSLOCO_TRANSPILER);
+        this.appRef = inject(ApplicationRef);
+        this.languageChangeSubscriptions = new Set();
+    }
+    /**
+     * Is the translation deactivation enabled
+     */
+    isTranslationDeactivationEnabled() {
+        return this.localizationService.isTranslationDeactivationEnabled();
+    }
+    /**
+     * Show localization keys
+     * @param value value enforced by the DevTools extension
+     */
+    showLocalizationKeys(value) {
+        this.localizationService.toggleShowKeys(value);
+        this.appRef.tick();
+    }
+    /**
+     * Returns the current language
+     */
+    getCurrentLanguage() {
+        return this.localizationService.getCurrentLanguage();
+    }
+    /**
+     * Set up a listener on language change
+     * @param fn called when the language is changed in the app
+     * @returns Object with unsubscribe() method to prevent memory leaks
+     */
+    onLanguageChange(fn) {
+        const subscription = this.localizationService
+            .getTranslateService()
+            .langChanges$
+            .subscribe((lang) => {
+            fn(lang);
+        });
+        this.languageChangeSubscriptions.add(subscription);
+        // Return custom object with unsubscribe method
+        return {
+            unsubscribe: () => {
+                subscription.unsubscribe();
+                this.languageChangeSubscriptions.delete(subscription);
+            }
+        };
+    }
+    /**
+     * Clear all language change listeners
+     */
+    clearLanguageChangeListeners() {
+        this.languageChangeSubscriptions.forEach((sub) => sub.unsubscribe());
+        this.languageChangeSubscriptions.clear();
+    }
+    /**
+     * Cleanup subscriptions when service is destroyed
+     */
+    ngOnDestroy() {
+        this.clearLanguageChangeListeners();
+    }
+    /**
+     * Switch the current language to the specified value
+     * @param language new language to switch to
+     */
+    async switchLanguage(language) {
+        if (!language) {
+            return;
+        }
+        await lastValueFrom(this.localizationService.useLanguage(language));
+        this.appRef.tick();
+    }
+    /**
+     * Updates the specified localization key/values for the current language.
+     *
+     * Recommendation: To be used with a small number of keys to update to avoid performance issues.
+     * @param keyValues key/values to update
+     * @param language if not provided, the current language value
+     */
+    updateLocalizationKeys(keyValues, language) {
+        const lang = language || this.getCurrentLanguage();
+        const translateService = this.localizationService.getTranslateService();
+        Object.entries(keyValues).forEach(([key, value]) => {
+            translateService.setTranslationKey(key, value, { lang });
+        });
+        this.appRef.tick();
+    }
+    /**
+     * Reload a language from the language file
+     * @param language language to reload
+     */
+    async reloadLocalizationKeys(language) {
+        const lang = language || this.getCurrentLanguage();
+        if (this.translateTranspiler.setLocale) {
+            this.translateTranspiler.setLocale(null);
+        }
+        const translateService = this.localizationService.getTranslateService();
+        const translations = await lastValueFrom(translateService.load(lang));
+        translateService.setTranslation(translations, lang, { merge: false });
+        this.appRef.tick();
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: OtterLocalizationDevtools, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: OtterLocalizationDevtools }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: OtterLocalizationDevtools, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Default configuration options for the Otter Localization Devtools
+ */
+const OTTER_LOCALIZATION_DEVTOOLS_DEFAULT_OPTIONS = {
+    isActivatedOnBootstrap: false,
+    isActivatedOnBootstrapWhenCMSContext: true,
+    metadataFilePath: './metadata/localisation.metadata.json'
+};
+/**
+ * Injection token for Otter Localization Devtools configuration options
+ */
+const OTTER_LOCALIZATION_DEVTOOLS_OPTIONS = new InjectionToken('Otter Localization Devtools options');
+
+/* eslint-disable no-console -- This is the purpose of this service */
+/**
+ * Service that exposes localization devtools functionality via the browser console
+ */
+class LocalizationDevtoolsConsoleService {
+    /** Name of the Window property to access to the devtools */
+    static { this.windowModuleName = 'localization'; }
+    constructor() {
+        this.localizationDevtools = inject(OtterLocalizationDevtools);
+        this.options = inject(OTTER_LOCALIZATION_DEVTOOLS_OPTIONS, { optional: true }) ?? OTTER_LOCALIZATION_DEVTOOLS_DEFAULT_OPTIONS;
+        if (this.options.isActivatedOnBootstrap
+            || (this.options.isActivatedOnBootstrapWhenCMSContext
+                && document.body.dataset.cmscontext === 'true')) {
+            this.activate();
+        }
+    }
+    /** @inheritDoc */
+    activate() {
+        const windowWithDevtools = window;
+        windowWithDevtools._OTTER_DEVTOOLS_ ||= {};
+        windowWithDevtools._OTTER_DEVTOOLS_[LocalizationDevtoolsConsoleService.windowModuleName] = this;
+        console.info(`Otter localization Devtools is now accessible via the _OTTER_DEVTOOLS_.${LocalizationDevtoolsConsoleService.windowModuleName} variable`);
+    }
+    /**
+     * @inheritdoc
+     */
+    isTranslationDeactivationEnabled() {
+        return this.localizationDevtools.isTranslationDeactivationEnabled();
+    }
+    /**
+     * @inheritdoc
+     */
+    showLocalizationKeys(value) {
+        this.localizationDevtools.showLocalizationKeys(value);
+    }
+    /**
+     * @inheritdoc
+     */
+    getCurrentLanguage() {
+        const currentLanguage = this.localizationDevtools.getCurrentLanguage();
+        return currentLanguage;
+    }
+    /**
+     * @inheritdoc
+     */
+    async switchLanguage(language) {
+        const previous = this.localizationDevtools.getCurrentLanguage();
+        await this.localizationDevtools.switchLanguage(language);
+        const current = this.localizationDevtools.getCurrentLanguage();
+        return {
+            requested: language,
+            previous,
+            current
+        };
+    }
+    /**
+     * @inheritdoc
+     */
+    onLanguageChange(fn) {
+        return this.localizationDevtools.onLanguageChange(fn);
+    }
+    /**
+     * @inheritdoc
+     */
+    clearLanguageChangeListeners() {
+        this.localizationDevtools.clearLanguageChangeListeners();
+    }
+    /**
+     * @inheritdoc
+     */
+    updateLocalizationKeys(keyValues, language) {
+        return this.localizationDevtools.updateLocalizationKeys(keyValues, language);
+    }
+    /**
+     * @inheritdoc
+     */
+    reloadLocalizationKeys(language) {
+        return this.localizationDevtools.reloadLocalizationKeys(language);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizationDevtoolsConsoleService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizationDevtoolsConsoleService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizationDevtoolsConsoleService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+/**
+ * Type guard to check if a message is a localization message
+ * @param message Message to check
+ * @returns True if the message is a localization message
+ */
+const isLocalizationMessage = (message) => {
+    return message && (message.dataType === 'displayLocalizationKeys'
+        || message.dataType === 'languages'
+        || message.dataType === 'switchLanguage'
+        || message.dataType === 'localizations'
+        || message.dataType === 'updateLocalization'
+        || message.dataType === 'requestMessages'
+        || message.dataType === 'connect'
+        || message.dataType === 'reloadLocalizationKeys'
+        || message.dataType === 'isTranslationDeactivationEnabled'
+        || message.dataType === 'getTranslationValuesContentMessage');
+};
+/**
+ * Service that handles localization devtools messages communication
+ */
+class LocalizationDevtoolsMessageService {
+    constructor() {
+        this.logger = inject(LoggerService);
+        this.localizationDevTools = inject(OtterLocalizationDevtools);
+        this.localizationService = inject(LocalizationService);
+        this.options = inject(OTTER_LOCALIZATION_DEVTOOLS_OPTIONS, { optional: true }) ?? OTTER_LOCALIZATION_DEVTOOLS_DEFAULT_OPTIONS;
+        this.sendMessage = (sendOtterMessage);
+        this.destroyRef = inject(DestroyRef);
+        this.options = {
+            ...OTTER_LOCALIZATION_DEVTOOLS_DEFAULT_OPTIONS,
+            ...this.options
+        };
+        if (this.options.isActivatedOnBootstrap) {
+            this.activate();
+        }
+    }
+    async sendLocalizationsMetadata() {
+        const metadata = await (await fetch(this.options.metadataFilePath)).json();
+        this.sendMessage('localizations', {
+            localizations: metadata
+        });
+    }
+    /**
+     * Function to trigger a re-send a requested messages to the Otter Chrome DevTools extension
+     * @param only restricted list of messages to re-send
+     */
+    handleReEmitRequest(only) {
+        if (!only || only.includes('localizations')) {
+            void this.sendLocalizationsMetadata();
+        }
+        if (!only || only.includes('switchLanguage')) {
+            this.sendMessage('switchLanguage', { language: this.localizationDevTools.getCurrentLanguage() });
+        }
+        if (!only || only.includes('languages')) {
+            this.sendMessage('languages', { languages: this.localizationService.getLanguages() });
+        }
+        if (!only || only.includes('getTranslationValuesContentMessage')) {
+            this.sendMessage('getTranslationValuesContentMessage', {
+                translations: this.localizationService.getTranslateService().getTranslation(this.localizationService.getCurrentLanguage())
+            });
+        }
+        if (!only || only.includes('isTranslationDeactivationEnabled')) {
+            this.sendMessage('isTranslationDeactivationEnabled', { enabled: this.localizationService.isTranslationDeactivationEnabled() });
+        }
+    }
+    /**
+     * Function to handle the incoming messages from Otter Chrome DevTools extension
+     * @param message Message coming from the Otter Chrome DevTools extension
+     */
+    handleEvents(message) {
+        this.logger.debug('Message handling by the localization service', message);
+        switch (message.dataType) {
+            case 'connect': {
+                this.connectPlugin();
+                break;
+            }
+            case 'displayLocalizationKeys': {
+                this.localizationDevTools.showLocalizationKeys(message.toggle);
+                break;
+            }
+            case 'requestMessages': {
+                void this.handleReEmitRequest(message.only);
+                break;
+            }
+            case 'switchLanguage': {
+                void this.localizationDevTools.switchLanguage(message.language);
+                break;
+            }
+            case 'updateLocalization': {
+                void this.localizationDevTools.updateLocalizationKeys({
+                    [message.key]: message.value
+                }, message.lang);
+                break;
+            }
+            case 'reloadLocalizationKeys': {
+                void this.localizationDevTools.reloadLocalizationKeys(message.lang);
+                break;
+            }
+            default: {
+                this.logger.warn('Message ignored by the localization service', message);
+            }
+        }
+    }
+    /**
+     * Function to connect the plugin to the Otter Chrome DevTools extension
+     */
+    connectPlugin() {
+        this.logger.debug('Otter DevTools is plugged to localization service of the application');
+    }
+    /** @inheritDoc */
+    activate() {
+        fromEvent(window, 'message').pipe(takeUntilDestroyed(this.destroyRef), filterMessageContent(isLocalizationMessage)).subscribe((e) => this.handleEvents(e));
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizationDevtoolsMessageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizationDevtoolsMessageService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.15", ngImport: i0, type: LocalizationDevtoolsMessageService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+/**
+ * Provide localization devtools functionality for the application.
+ * This is the recommended way to set up localization devtools in standalone applications.
+ * @param options Optional partial localization devtools configuration to override defaults. Can be a configuration object or a factory function.
+ * @example Load localization with automatic activation at bootstrap
+ * ```typescript
+ * bootstrapApplication(App, {
+ *   providers: [
+ *     provideLocalizationDevtools({ isActivatedOnBootstrap: true })
+ *   ]
+ * });
+ * ```
+ */
+function provideLocalizationDevtools(options) {
+    return makeEnvironmentProviders([
+        {
+            provide: OTTER_LOCALIZATION_DEVTOOLS_OPTIONS,
+            useValue: { ...OTTER_LOCALIZATION_DEVTOOLS_DEFAULT_OPTIONS, ...options }
+        },
+        LocalizationDevtoolsMessageService,
+        LocalizationDevtoolsConsoleService,
+        OtterLocalizationDevtools
+    ]);
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CUSTOM_LOCALIZATION_CONFIGURATION_TOKEN, DEFAULT_LOCALIZATION_CONFIGURATION, LOCALIZATION_CONFIGURATION_TOKEN, LOCALIZATION_OVERRIDE_REDUCER_TOKEN, LOCALIZATION_OVERRIDE_STORE_NAME, Localization, LocalizationDevtoolsConsoleService, LocalizationDevtoolsMessageService, LocalizationOverrideStoreModule, LocalizationService, LocalizationTranslateDirective, LocalizedCurrencyPipe, LocalizedDatePipe, LocalizedDecimalPipe, O3rLocalizationTranslatePipe, OTTER_LOCALIZATION_DEVTOOLS_DEFAULT_OPTIONS, OTTER_LOCALIZATION_DEVTOOLS_OPTIONS, OtterLocalizationDevtools, TextDirectionService, TranslationsLoader, createLocalizationConfiguration, createTranslateLoader, getDebugKey, getDefaultLocalizationOverrideReducer, localeIdNgBridge, localizationOverrideInitialState, localizationOverrideReducer, localizationOverrideReducerFeatures, localizationOverrideStorageDeserializer, localizationOverrideStorageSync, provideLocalization, provideLocalizationDevtools, selectLocalizationOverride, selectLocalizationOverrideState, setLocalizationOverride, translateLoaderProvider };
+//# sourceMappingURL=o3r-transloco.mjs.map