@bravobit/bb-foundation 0.22.4 → 0.23.2

package/fesm2020/bravobit-bb-foundation-localize.mjs

@@ -1,13 +1,15 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Directive, Input, Component, ChangeDetectionStrategy, ViewEncapsulation, ContentChildren, Injectable, Optional, Inject, Pipe, APP_INITIALIZER, LOCALE_ID, NgModule } from '@angular/core';
+import { InjectionToken, Optional, Inject, Directive, Input, Component, ChangeDetectionStrategy, ViewEncapsulation, ContentChildren, Injectable, Pipe, APP_INITIALIZER, LOCALE_ID, NgModule } from '@angular/core';
 import * as i1 from '@angular/common';
 import { formatDate, DOCUMENT, CommonModule } from '@angular/common';
+import { __decorate, __param } from 'tslib';
 import { startWith } from 'rxjs/operators';
 import { Subscription } from 'rxjs';
 import * as i2 from '@bravobit/bb-foundation/utils';
 import { UtilsModule } from '@bravobit/bb-foundation/utils';
-import * as i1$1 from '@bravobit/bb-foundation/storage';
 import * as i2$1 from '@bravobit/bb-foundation';
+import { WINDOW } from '@bravobit/bb-foundation';
+import * as i1$1 from '@bravobit/bb-foundation/storage';
 
 //
 // The configuration that can be passed when
@@ -25,6 +27,8 @@ class LocalizeConfig {
 //
 const LOCALIZE_FUNCTION = new InjectionToken('localize_function');
 
+const LOCALIZE_TRANSFORM = new InjectionToken('localize_transform');
+
 //
 // This function transform the value
 // to a lowercase variant of the value.
@@ -34,7 +38,7 @@ class LocalizeLowercaseFunction {
         return 'lowercase';
     }
     transform(value) {
-        return (value || '').toLowerCase();
+        return (value ?? '').toLowerCase();
     }
 }
 
@@ -47,7 +51,7 @@ class LocalizeUppercaseFunction {
         return 'uppercase';
     }
     transform(value) {
-        return (value || '').toUpperCase();
+        return (value ?? '').toUpperCase();
     }
 }
 
@@ -166,13 +170,236 @@ class LocalizeMissingHandler {
         // Log to the console when the token was not found
         // if the user did not mark it as optional.
         if (!params?.optional) {
-            this.log(`Localize: The token with name: "${params?.token}" was not found.`);
+            this.log(`The token with name: "${params?.token}" was not found.`);
         }
         // Return the default token back.
         return params?.token ?? null;
     }
 }
 
+class LocalizeDictionaryData {
+    constructor(data) {
+        this.data = data;
+    }
+}
+
+class LocalizeDictionaryContext {
+    constructor() {
+        this.regexp = /^.*$/;
+    }
+    pattern(regexp) {
+        this.regexp = regexp;
+        return this;
+    }
+    matches(value) {
+        const formatted = this.formatValue(value);
+        const regex = (formatted ?? '')
+            .replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
+            .replace(/\\\*/g, '.*');
+        return this.pattern(new RegExp(`^${regex}$`));
+    }
+    group(value) {
+        const formatted = this.formatValue(value);
+        return this.matches([formatted, '*']);
+    }
+    formatValue(value) {
+        return Array.isArray(value)
+            ? value.filter(item => !!item).join('.')
+            : value;
+    }
+}
+
+class LocalizeDictionary {
+    constructor(_id, _locale, _supported, _dataValues, _localize) {
+        this._id = _id;
+        this._locale = _locale;
+        this._supported = _supported;
+        this._dataValues = _dataValues;
+        this._localize = _localize;
+        this._data = this.formatData(this._dataValues);
+    }
+    get id() {
+        return this._id ?? null;
+    }
+    get locale() {
+        return this._locale ?? null;
+    }
+    get supported() {
+        return this._supported ?? [];
+    }
+    get(token) {
+        const key = Array.isArray(token) ? token.join('.') : token;
+        return this._data?.[key] ?? null;
+    }
+    has(token) {
+        return !!this.get(token);
+    }
+    all() {
+        return this.some(context => context);
+    }
+    some(callback) {
+        const defaultContext = new LocalizeDictionaryContext();
+        const context = !!callback ? callback(defaultContext) : defaultContext;
+        return Object.keys(this._data ?? {})
+            .filter(key => context.regexp.test(key))
+            .reduce((previous, current) => ([
+            ...previous,
+            { token: current, value: this.get(current) }
+        ]), []);
+    }
+    async compare(to) {
+        if ((typeof ngDevMode === 'undefined' || ngDevMode)) {
+            const dictionaryIds = (Array.isArray(to) ? to : [to]);
+            const dictionaries = [];
+            for (const dictionaryId of dictionaryIds) {
+                console.log(`Making sure dictionary "${dictionaryId}" is loaded.`);
+                const dictionary = await this._localize.load(dictionaryId);
+                dictionaries.push(dictionary);
+            }
+            const warnings = [];
+            const items = this.all();
+            for (const item of items) {
+                for (const dictionary of dictionaries) {
+                    if (!dictionary.has(item?.token)) {
+                        warnings.push({ dictionary: dictionary?.id, value: item?.token });
+                    }
+                }
+            }
+            for (const dictionary of dictionaries) {
+                const items = dictionary.all();
+                for (const item of items) {
+                    if (!this.has(item?.token)) {
+                        warnings.push({ dictionary: this.id, value: item?.token });
+                    }
+                }
+            }
+            const compareDictionaryIds = dictionaries.map(dictionary => dictionary?.id).join(', ');
+            console.log(`Comparing currency dictionary [${this.id}] with [${compareDictionaryIds}]...`);
+            for (const warning of warnings) {
+                console?.warn?.(`Dictionary "${warning.dictionary}" is missing token "${warning.value}"`);
+            }
+            console?.warn?.(`Total of ${warnings.length} warning(s) found.`);
+        }
+    }
+    count() {
+        return Object.keys(this._data ?? {}).length;
+    }
+    formatData(data, scope = null) {
+        return Object.keys(data ?? {}).reduce((previous, current) => {
+            const value = data?.[current];
+            if (typeof value === 'object' && value !== null) {
+                const reformatted = this.formatData(value, current);
+                return { ...previous, ...reformatted };
+            }
+            const token = [scope, current].filter(item => !!item).join('.');
+            if (previous[token] && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+                console?.warn?.(`Duplicate key "${token}" was found, please verify your translation files.`);
+            }
+            return { ...previous, [token]: value };
+        }, {});
+    }
+}
+
+class LocalizeTransform {
+    getMatches(value, substitutions) {
+        // Validate our value exists, else return zero matches.
+        if (value === undefined || value === null) {
+            return [];
+        }
+        // Get the matching substitutions.
+        const { start, end } = this.getSubstitutions(substitutions);
+        // Compose a regex that will find the matches.
+        const regex = new RegExp(`${start}([^${end}]+)${end}`, 'g');
+        // Execute the regex to find matches.
+        let match = regex.exec(value);
+        const matches = [];
+        while (match !== null) {
+            matches.push({ match: match[0], token: match[1] });
+            match = regex.exec(value);
+        }
+        // Return the processed value.
+        return matches.filter(item => !!item);
+    }
+    getSubstitutions(value) {
+        // Escape both substitutions so that they can be used.
+        const escape = /[.*+?^${}()|[\]\\]/g;
+        const start = value[0].replace(escape, '\\$&');
+        const end = value[1].replace(escape, '\\$&');
+        // Return the substitutions.
+        return { start, end };
+    }
+}
+
+let LocalizeInterpolateTransform = class LocalizeInterpolateTransform extends LocalizeTransform {
+    constructor(config, functions) {
+        super();
+        this.config = config;
+        this.functions = functions;
+        this.substitutions = this.config?.substitutions?.references ?? ['{{', '}}'];
+        this.functionsMap = (this.functions ?? []).reduce((previous, current) => {
+            previous[current?.keyword()] = current;
+            return previous;
+        }, {});
+    }
+    execute(value, data, localize) {
+        const matches = this.getMatches(value, this.substitutions);
+        // Replace all matches with the translated value.
+        return matches.reduce((previous, current) => {
+            // Try to parse the token.
+            const interpolatedToken = this.parseInterpolationToken(current?.token, data, localize);
+            // Replace the match with the translated token.
+            return previous.replace(current?.match, interpolatedToken);
+        }, value);
+    }
+    parseInterpolationToken(value, data, localize) {
+        // Get the token and the methods by splitting
+        // on the pipe symbol.
+        const [token, ...methods] = (value ?? '').split('|').map(item => item.trim());
+        // Get the value for the token from
+        // the interpolation data.
+        const interpolationValue = data?.[token] ?? 'null';
+        // Loop through all the middleware methods and try to
+        // conform the string to the given parameters.
+        return methods.reduce((string, middlewareName) => {
+            // Try to retrieve the middleware from the collection.
+            const middleware = this.functionsMap?.[middlewareName];
+            // If the middleware is missing return an error
+            // so that the user knows it was not found.
+            if (!middleware) {
+                return string;
+            }
+            // Execute the middleware function with the string.
+            return middleware.transform(string, localize?.current?.locale);
+        }, `${interpolationValue}`);
+    }
+};
+LocalizeInterpolateTransform = __decorate([
+    __param(0, Optional()),
+    __param(1, Optional()),
+    __param(1, Inject(LOCALIZE_FUNCTION))
+], LocalizeInterpolateTransform);
+
+let LocalizeReferenceTransform = class LocalizeReferenceTransform extends LocalizeTransform {
+    constructor(config) {
+        super();
+        this.config = config;
+        this.substitutions = this.config?.substitutions?.references ?? ['#(', ')'];
+    }
+    execute(value, _, localize) {
+        const matches = this.getMatches(value, this.substitutions);
+        // Replace all matches with the translated value.
+        return matches.reduce((previous, current) => {
+            // Try to translate the token.
+            const translatedToken = localize.translate(current?.token);
+            // Replace the match with the translated token.
+            return previous.replace(current?.match, translatedToken);
+        }, value);
+    }
+};
+LocalizeReferenceTransform = __decorate([
+    __param(0, Optional())
+], LocalizeReferenceTransform);
+
 class BbLocalizeTemplate {
     constructor(templateRef) {
         this.templateRef = templateRef;
@@ -273,188 +500,104 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImpor
                 type: Input
             }] } });
 
-class LocalizeDictionary {
-    constructor(data) {
-        this._data = this.formatData(data);
-    }
-    get(token) {
-        const key = Array.isArray(token) ? token.join('.') : token;
-        return this._data?.[key] ?? null;
-    }
-    formatData(data, scope = null) {
-        return Object.keys(data).reduce((previous, current) => {
-            const value = data?.[current];
-            if (typeof value === 'object' && value !== null) {
-                const reformatted = this.formatData(value, current);
-                return { ...previous, ...reformatted };
-            }
-            const token = [scope, current].filter(item => !!item).join('.');
-            if (previous[token] && (typeof ngDevMode === 'undefined' || ngDevMode)) {
-                console?.warn?.(`Localize: Duplicate key "${token}" was found, please verify your translation files.`);
-            }
-            return { ...previous, [token]: value };
-        }, {});
-    }
-}
-
 class Localize {
-    constructor(_storage, _languages, _config, _missingHandler, _document, _functions) {
+    constructor(_storage, _languages, _missingHandler, _config, _window, _document, _transforms) {
         this._storage = _storage;
         this._languages = _languages;
-        this._config = _config;
         this._missingHandler = _missingHandler;
+        this._config = _config;
+        this._window = _window;
         this._document = _document;
-        this._functions = _functions;
-        this._storageToken = 'bb-language-dictionary-id';
-        // Current language dictionary.
-        this._currentLanguage = null;
-        this._currentDictionary = null;
+        this._transforms = _transforms;
+        // Readonly data.
+        this._storageToken = this._config?.storageToken ?? 'bb-language-dictionary-id';
+        this._availableLanguages = this?._config?.languages ?? [];
+        this._bestMatchingLanguage = this.retrieveBestMatchingLanguage();
+        this._loadedDictionaries = new Map();
+        // Current dictionary.
+        this._current = null;
         this.convertToParams = (tokenOrParams) => {
             if (typeof tokenOrParams !== 'string') {
                 // Destruct the params from the object.
-                const { token, optional, data } = tokenOrParams;
+                const { token, optional, dictionary, data } = tokenOrParams;
                 // Make sure all parameters are valid
                 // by type safe adding them.
-                return { token: token, optional: optional ?? false, data: data ?? {} };
+                return { token: token, optional: optional ?? false, dictionary: dictionary ?? null, data: data ?? {} };
             }
             // If the parameter is a string fill in the blanks.
-            return { token: tokenOrParams, optional: false, data: {} };
-        };
-        this.getMatches = (value, substitutions) => {
-            // Get the matching substitutions.
-            const { start, end } = substitutions;
-            // Compose a regex that will find the matches.
-            const regex = new RegExp(`${start}([^${end}]+)${end}`, 'g');
-            // Execute the regex to find matches.
-            let match = regex.exec(value);
-            const matches = [];
-            while (match !== null) {
-                matches.push({ match: match[0], token: match[1] });
-                match = regex.exec(value);
-            }
-            // Return the processed value.
-            return matches.filter(item => !!item);
+            return { token: tokenOrParams, optional: false, dictionary: null, data: {} };
         };
-        // Check if at least one language was passed in the config.
-        this._availableLanguages = this._config.languages;
-        if (this._availableLanguages.length < 1) {
-            throw new Error('Localize: one or more languages should be supplied.');
-        }
-        // Gather all the localize functions.
-        this._functionMiddleware = this._functions.reduce((previous, current) => {
-            previous[current.keyword()] = current;
-            return previous;
-        }, {});
-        // Save the best matching current dictionary.
-        this._bestMatchingLanguage = this.retrieveBestMatchingLanguage();
         this.renderDocumentLanguage();
     }
     get languages() {
         return this._availableLanguages ?? [];
     }
     get current() {
-        return this._currentLanguage;
-    }
-    async set(language, cache = true) {
-        // Await the language data and set the current
-        // dictionary to the loaded data.
-        this._currentLanguage = language ?? this._availableLanguages?.[0];
-        if (this._currentLanguage) {
-            this._currentDictionary = await this._currentLanguage.data();
+        return this._current;
+    }
+    async load(id) {
+        if (id === null || id === undefined) {
+            throw new Error(`Cannot load language with id: "${id}".`);
+        }
+        if (this._loadedDictionaries.has(id)) {
+            return this._loadedDictionaries.get(id);
         }
-        // Save the selected language in the storage.
+        const language = this.languages?.find(language => language?.id === id);
+        if (!language || !language?.data) {
+            console?.warn?.(`No language was found with id: "${id}"; Defaulting to first available language.`);
+            const languageId = this.languages?.[0]?.id ?? null;
+            return this.load(languageId);
+        }
+        const dictionaryDataValues = await language?.data?.();
+        const dictionary = this.createDictionary(dictionaryDataValues, language);
+        this._loadedDictionaries.set(id, dictionary);
+        return dictionary;
+    }
+    async switch(id, options) {
+        this._current = await this.load(id);
+        const cache = options?.cache ?? true;
         if (cache) {
-            this._storage.cookie.set(this._storageToken, this._currentLanguage?.id, {});
+            this._storage.cookie.set(this._storageToken, this._current?.id, {});
+        }
+        const reload = options?.reload ?? false;
+        if (reload) {
+            this._window?.location?.reload?.();
         }
+        return this._current;
+    }
+    select(id) {
+        if (!this._loadedDictionaries.has(id)) {
+            throw new Error(`Dictionary with id: "${id}" not loaded; Load dictionary first before using .select(:id).`);
+        }
+        return this._loadedDictionaries.get(id);
     }
     initialize() {
-        return async () => this.set(this._bestMatchingLanguage, false);
+        return async () => this.switch(this._bestMatchingLanguage?.id, { reload: false, cache: false });
     }
     clear() {
         this._storage.cookie.remove(this._storageToken);
     }
+    transform(value, data = {}) {
+        return (this._transforms ?? []).reduce((previous, current) => {
+            return current.execute(previous, data, this);
+        }, value);
+    }
     translate(tokenOrParams) {
         // 1. Convert to the params.
         const params = this.convertToParams(tokenOrParams);
         // 2. Try to find the translation in the dictionary.
-        const searchResult = this._currentDictionary.get(params?.token);
+        const dictionary = this.getDictionary(params?.dictionary);
+        const searchResult = !!dictionary ? dictionary.get(params?.token) : null;
         // 3. Verify the translation was found.
         if (!searchResult) {
             return this._missingHandler.handle(params);
         }
-        // 4. Find references in the translation that need to be translated as well.
-        const processResult = this.findReferencesInTranslation(searchResult);
-        // 5. Parse the interpolation data.
-        return this.parseInterpolationData(processResult, params?.data);
-    }
-    parseInterpolationData(value, data) {
-        // Get the interpolation substitutions.
-        const substitutions = this.getSubstitutions('interpolation', ['{{', '}}']);
-        // Get all matches in the value.
-        const matches = this.getMatches(value, substitutions);
-        // Replace all matches with the parsed value.
-        return matches.reduce((previous, current) => {
-            // Try to parse the token.
-            const interpolatedToken = this.interpolateFunctionData(current?.token, data);
-            // Replace the match with the parsed token.
-            return previous.replace(current?.match, interpolatedToken);
-        }, `${value}`);
-    }
-    interpolateFunctionData(value, interpolationData) {
-        // Get the token and the methods by splitting
-        // on the pipe symbol.
-        const [token, ...methods] = value.split('|').map(item => item.trim());
-        // Get the value for the token from
-        // the interpolation data.
-        const interpolationValue = interpolationData?.[token] ?? token;
-        // Loop through all the middleware methods and try to
-        // conform the string to the given parameters.
-        return methods.reduce((string, middlewareName) => {
-            // Try to retrieve the middleware from the collection.
-            const middleware = this._functionMiddleware[middlewareName];
-            // If the middleware is missing return an error
-            // so that the user knows it was not found.
-            if (!middleware) {
-                return string;
-            }
-            // Execute the middleware function with the string.
-            return middleware.transform(string, this.current?.locale);
-        }, `${interpolationValue}`);
-    }
-    findReferencesInTranslation(value) {
-        // Get the reference substitutions.
-        const substitutions = this.getSubstitutions('references', ['#(', ')']);
-        // Get all matches in the value.
-        const matches = this.getMatches(value, substitutions);
-        // Replace all matches with the translated value.
-        return matches.reduce((previous, current) => {
-            // Try to translate the token.
-            const translatedToken = this.translate(current?.token);
-            // Replace the match with the translated token.
-            return previous.replace(current?.match, translatedToken);
-        }, value);
-    }
-    getSubstitutions(type, defaultValue) {
-        // Get the substitutions.
-        const substitutions = this._config?.substitutions?.[type] ?? null;
-        const value = (!substitutions || substitutions.length !== 2)
-            ? defaultValue
-            : substitutions;
-        // Escape both substitutions so that they
-        // can be used.
-        const escape = /[.*+?^${}()|[\]\\]/g;
-        const start = value[0].replace(escape, '\\$&');
-        const end = value[1].replace(escape, '\\$&');
-        // Return the substitutions.
-        return { start, end };
+        return this.transform(searchResult, params?.data);
     }
     retrieveBestMatchingLanguage() {
-        // Get the language based on storage.
-        const storageLanguage = this.getLanguageFromStorage();
-        // Get the language based on the supported languages of the browser.
-        const browserLanguage = this.getBestBrowserMatchLanguage();
-        // Return the best matching language.
-        return storageLanguage ?? browserLanguage ?? this._availableLanguages?.[0];
+        return this.getLanguageFromStorage()
+            ?? this.getBestBrowserMatchLanguage()
+            ?? this._availableLanguages?.[0];
     }
     getLanguageFromStorage() {
         // Get id from the storage.
@@ -470,6 +613,15 @@ class Localize {
             return this._availableLanguages.find(item => item?.supported?.includes(languageCode));
         }).filter(item => !!item).find((_, index) => index === 0);
     }
+    createDictionary(data, language) {
+        return new LocalizeDictionary(language?.id, language?.locale, language?.supported, data?.data, this);
+    }
+    getDictionary(id) {
+        if (id === null || id === undefined) {
+            return this._current;
+        }
+        return this.select(id);
+    }
     renderDocumentLanguage() {
         const element = this._document?.documentElement;
         if (!element) {
@@ -478,13 +630,18 @@ class Localize {
         element.lang = this._bestMatchingLanguage?.supported?.[0] ?? this._bestMatchingLanguage?.locale;
     }
 }
-Localize.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: Localize, deps: [{ token: i1$1.Storage }, { token: i2$1.Languages }, { token: LocalizeConfig, optional: true }, { token: LocalizeMissingHandler }, { token: DOCUMENT, optional: true }, { token: LOCALIZE_FUNCTION, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+Localize.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: Localize, deps: [{ token: i1$1.Storage }, { token: i2$1.Languages }, { token: LocalizeMissingHandler }, { token: LocalizeConfig, optional: true }, { token: WINDOW, optional: true }, { token: DOCUMENT, optional: true }, { token: LOCALIZE_TRANSFORM, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
 Localize.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: Localize });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: Localize, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: i1$1.Storage }, { type: i2$1.Languages }, { type: LocalizeConfig, decorators: [{
+        }], ctorParameters: function () { return [{ type: i1$1.Storage }, { type: i2$1.Languages }, { type: LocalizeMissingHandler }, { type: LocalizeConfig, decorators: [{
                     type: Optional
-                }] }, { type: LocalizeMissingHandler }, { type: Document, decorators: [{
+                }] }, { type: Window, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [WINDOW]
+                }] }, { type: Document, decorators: [{
                     type: Optional
                 }, {
                     type: Inject,
@@ -493,7 +650,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImpor
                     type: Optional
                 }, {
                     type: Inject,
-                    args: [LOCALIZE_FUNCTION]
+                    args: [LOCALIZE_TRANSFORM]
                 }] }]; } });
 
 class BbLocalize {
@@ -501,31 +658,28 @@ class BbLocalize {
         this._localize = _localize;
     }
     transform(tokenOrParams, args) {
-        // Validate that the localize service
-        // exists in the pipe.
+        // Combine the params with the options to form the localize params.
+        const params = this.combineParamsWithOptions(tokenOrParams, args);
+        // Validate that the localize service exists in the pipe.
         if (!this._localize) {
-            return tokenOrParams;
+            return params?.token ?? null;
         }
-        // Combine the params with the options
-        // to form the localize params.
-        const params = this.combineParamsWithOptions(tokenOrParams, args);
         // Try to localize the value.
         return this._localize.translate(params);
     }
     combineParamsWithOptions(tokenOrParams, args) {
         // Gather the extras.
-        const extras = args || {};
+        const extras = args ?? {};
         // Loop through all the keys to find the set options.
         const options = Object.keys(extras).reduce((previous, current) => {
-            if (typeof extras[current] === 'undefined') {
+            if (typeof extras?.[current] === 'undefined') {
                 return previous;
             }
-            previous[current] = extras[current];
-            return previous;
+            return { ...previous, [current]: extras?.[current] };
         }, {});
         // Convert the string token to a params object.
         const params = typeof tokenOrParams === 'string'
-            ? { token: tokenOrParams, optional: false, data: {} }
+            ? { token: tokenOrParams, optional: false, data: {}, dictionary: null }
             : tokenOrParams;
         // Return the combined params and options.
         return { ...params, ...options };
@@ -544,12 +698,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImpor
 
 class LocalizeModule {
     static forRoot(config) {
-        const automatic = config?.automatic ?? true;
+        if (config?.languages?.length <= 0) {
+            throw new Error('One or more languages should be supplied.');
+        }
+        const mode = config?.mode ?? 'automatic';
         return {
             ngModule: LocalizeModule,
             providers: [
                 // Angular providers.
-                ...(automatic ? [
+                ...(mode === 'automatic' ? [
                     { provide: APP_INITIALIZER, deps: [Localize], useFactory: initializeLocale, multi: true },
                     { provide: LOCALE_ID, deps: [Localize], useFactory: getLocale }
                 ] : []),
@@ -559,6 +716,9 @@ class LocalizeModule {
                 { provide: LOCALIZE_FUNCTION, useClass: LocalizeLowercaseFunction, multi: true },
                 { provide: LOCALIZE_FUNCTION, useClass: LocalizeUppercaseFunction, multi: true },
                 { provide: LOCALIZE_FUNCTION, useClass: LocalizeDateFunction, multi: true },
+                // Transform providers.
+                { provide: LOCALIZE_TRANSFORM, useClass: LocalizeReferenceTransform, deps: [LocalizeConfig], multi: true },
+                { provide: LOCALIZE_TRANSFORM, useClass: LocalizeInterpolateTransform, deps: [LocalizeConfig, LOCALIZE_FUNCTION], multi: true },
                 // Handler providers.
                 { provide: LocalizeMissingHandler, useClass: LocalizeMissingHandler },
                 // Service providers.
@@ -601,5 +761,5 @@ function getLocale(localize) {
  * Generated bundle index. Do not edit.
  */
 
-export { BbLocalize, BbLocalizeString, BbLocalizeTemplate, LOCALIZE_FUNCTION, Localize, LocalizeConfig, LocalizeDateFunction, LocalizeDictionary, LocalizeLowercaseFunction, LocalizeMissingHandler, LocalizeModule, LocalizeUppercaseFunction, extraDutchDictionary, extraEnglishDictionary, getLocale, initializeLocale };
+export { BbLocalize, BbLocalizeString, BbLocalizeTemplate, LOCALIZE_FUNCTION, LOCALIZE_TRANSFORM, Localize, LocalizeConfig, LocalizeDateFunction, LocalizeDictionary, LocalizeDictionaryContext, LocalizeDictionaryData, LocalizeInterpolateTransform, LocalizeLowercaseFunction, LocalizeMissingHandler, LocalizeModule, LocalizeReferenceTransform, LocalizeTransform, LocalizeUppercaseFunction, extraDutchDictionary, extraEnglishDictionary, getLocale, initializeLocale };
 //# sourceMappingURL=bravobit-bb-foundation-localize.mjs.map