@bootkit/ng0 0.0.0-alpha.4 → 0.0.0-alpha.40

package/fesm2022/bootkit-ng0-localization.mjs

@@ -1,7 +1,6 @@
 import * as i0 from '@angular/core';
-import { Injectable, Pipe, NgModule, InjectionToken } from '@angular/core';
+import { Injectable, Pipe, inject, runInInjectionContext, EnvironmentInjector, NgModule, InjectionToken } from '@angular/core';
 import { Subject } from 'rxjs';
-import { CommonModule } from '@angular/common';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 
 /** Locale */
@@ -20,22 +19,36 @@ class Locale {
     /**
      * Translates a key in the dictionary
      * @param key The key to look up
-     * @returns The translated string or the key itself if not found
+     * @param fallback Optional fallback value if the key is not found
+     * @returns The translated string or the fallbackValue if not found
      */
-    translate(key) {
-        return this.definition.dictionary?.[key] ?? key;
+    translate(key, fallback) {
+        return this.definition.dictionary?.[key] ?? fallback;
     }
     /**
      * Translates an enum value
      * @param enumName The name of the enum
      * @param enumValue The value of the enum to translate
+     * @param fallback
      * @returns The translated string or the enum value itself if not found
      */
-    translateEnum(enumName, enumValue) {
-        if (this.definition?.enums && this.definition.enums[enumName])
-            return this.definition.enums[enumName][enumValue];
-        else
-            return enumValue;
+    translateEnum(enumName, enumValue, fallback) {
+        let e = this.definition.enums?.[enumName];
+        if (!e) {
+            return fallback || enumValue?.toString();
+        }
+        if (enumValue === null) {
+            return e['[null]'] || e['[empty]'];
+        }
+        else if (enumValue === undefined) {
+            return e['[undefined]'] || e['[empty]'];
+        }
+        else if (enumValue === '') {
+            return e['empty'];
+        }
+        else {
+            return e[enumValue] || e['[?]'] || fallback || enumValue?.toString();
+        }
     }
     /**
    * Translates a form validation error
@@ -89,18 +102,8 @@ class Locale {
     /**
      * Clones and extends this object and returns a new Locale (without modifying this object).
      */
-    extend(values) {
-        return new Locale({
-            name: this.definition.name,
-            rtl: this.definition.rtl,
-            dictionary: { ...this.definition.dictionary, ...values?.dictionary },
-            enums: { ...this.definition.enums, ...values?.enums },
-            form: {
-                validation: {
-                    errors: { ...this.definition?.form?.validation?.errors, ...values?.form?.validation?.errors }
-                }
-            }
-        });
+    extend(definition) {
+        return new Locale({ ...this.definition, ...definition });
     }
     /**
    *
@@ -110,8 +113,29 @@ class Locale {
     formatDate(date, format) {
         return date ? new Date(date).toLocaleDateString(this.definition.name, { hour: '2-digit', minute: '2-digit' }) : '';
     }
+    format(object, formatterName, ...params) {
+        let formatter = this.definition.formatters?.[formatterName];
+        if (!formatter) {
+            throw Error(`The formatter "${formatterName}" is not defined in locale ${this.definition.name}`);
+        }
+        let formatterType = typeof formatter;
+        if (formatterType === 'function') {
+            return formatter(object, ...params);
+        }
+        else if (Array.isArray(formatter)) {
+            return formatter[+object];
+        }
+        else if (formatterType == 'object' && formatter != null) {
+            return formatter[object] || '';
+        }
+        else {
+            throw Error(`Invalid locale formatter: ${formatterName}`);
+        }
+    }
 }
 
+;
+
 class LocalizationService {
     _locales = [];
     _activeLocale;
@@ -147,147 +171,449 @@ class LocalizationService {
     get() {
         return this._activeLocale;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: LocalizationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: LocalizationService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: LocalizationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: LocalizationService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: LocalizationService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: LocalizationService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }], ctorParameters: () => [] });
 
+/**
+ * Pipe to translate a dictionary key into a localized string.
+ * It uses the LocalizationService to fetch the translation.
+ * If the translation is not found, it returns the fallback string if provided.
+ */
 class TranslatePipe {
-    _locale;
-    _recompute = true;
-    _value;
-    constructor(localizationService) {
-        this._locale = localizationService.get();
-        localizationService.change.pipe(takeUntilDestroyed()).subscribe(x => {
-            this._locale = x.new;
-            this._recompute = true;
-        });
-    }
-    transform(dictionaryKey, ...args) {
-        if (this._recompute) {
-            this._value = this._locale.translate(dictionaryKey);
-            this._recompute = false;
-        }
-        return this._value;
+    _ls;
+    constructor(_ls) {
+        this._ls = _ls;
+    }
+    transform(dictionaryKey, fallback) {
+        return this._ls.get()?.translate(dictionaryKey, fallback) || dictionaryKey;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: TranslatePipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
-    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.0.6", ngImport: i0, type: TranslatePipe, isStandalone: true, name: "ng0Translate", pure: false });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: TranslatePipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.11", ngImport: i0, type: TranslatePipe, isStandalone: true, name: "ng0Translate" });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: TranslatePipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: TranslatePipe, decorators: [{
             type: Pipe,
             args: [{
                     name: 'ng0Translate',
                     standalone: true,
+                    pure: true
+                }]
+        }], ctorParameters: () => [{ type: LocalizationService }] });
+
+class TranslateEnumPipe {
+    _ls;
+    constructor(_ls) {
+        this._ls = _ls;
+    }
+    /**
+     *
+     * @param enumValue
+     * @param enumName
+     * @param nullValueKey
+     * @param returnEnumAsFallback
+     * @param fallbackKey
+     * @returns
+     */
+    transform(enumValue, enumName, fallback) {
+        return this._ls.get()?.translateEnum(enumName, enumValue, fallback);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: TranslateEnumPipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.11", ngImport: i0, type: TranslateEnumPipe, isStandalone: true, name: "ng0TranslateEnum" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: TranslateEnumPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'ng0TranslateEnum',
+                    standalone: true,
+                    pure: true
+                }]
+        }], ctorParameters: () => [{ type: LocalizationService }] });
+
+class TranslateBooleanPipe {
+    localeProvider;
+    constructor(localeProvider) {
+        this.localeProvider = localeProvider;
+    }
+    transform(value, falseKey = 'true', trueKey = 'false') {
+        return this.localeProvider.get()?.translate(value ? trueKey : falseKey);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: TranslateBooleanPipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.11", ngImport: i0, type: TranslateBooleanPipe, isStandalone: true, name: "ng0TranslateBool" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: TranslateBooleanPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'ng0TranslateBool',
+                    standalone: true,
+                    pure: true
+                }]
+        }], ctorParameters: () => [{ type: LocalizationService }] });
+
+/**
+ * Default object formatter function.
+ * @param value The item to format.
+ * @returns The formatted string.
+ */
+function defaultFormatter(obj) {
+    return obj?.toString() || '';
+}
+/**
+ * Creates a field formatter that retrieves the value of a specified field from an object.
+ * @param field The field name to retrieve.
+ * @returns An ObjectFormatter function.
+ */
+function createFieldFormatter(field) {
+    return (obj) => obj?.[field];
+}
+/**
+ * Creates an index formatter that retrieves the value at a specified index from an array.
+ * @param index The index to retrieve (number or boolean).
+ * @returns An ObjectFormatter function.
+ */
+function createIndexFormatter(index) {
+    return (obj) => {
+        if (Array.isArray(obj)) {
+            return obj[+index]; // use + to cast boolean values to numbers
+        }
+        throw Error('Object is not an array');
+    };
+}
+/**
+ * Creates a number formatter.
+ * @param minimumIntegerDigits
+ * @param minimumFractionDigits
+ * @param maximumFractionDigits
+ * @param useGrouping
+ * @returns An ObjectFormatter function.
+ */
+function createNumberFormatter(minimumIntegerDigits, minimumFractionDigits, maximumFractionDigits, useGrouping = true) {
+    let locale = inject(LocalizationService, { optional: true })?.get();
+    const localeName = locale?.definition.name || 'en-US';
+    const f = new Intl.NumberFormat(localeName, {
+        minimumIntegerDigits,
+        minimumFractionDigits,
+        maximumFractionDigits,
+        useGrouping,
+    });
+    return (n) => Number.isFinite(n) ? f.format(n) : '';
+}
+/**
+ * Creates a currency formatter.
+ * @param minFractions
+ * @param maxFractions
+ * @returns
+ */
+function createCurrencyFormatter(minFractions = 1, maxFractions = 2) {
+    return (n, minFractions, maxFractions) => Number.isFinite(n) ? n.toString() : '';
+}
+function createDateFormatter(options) {
+    let intlOptions;
+    if (options && (typeof options === 'object')) {
+        intlOptions = options;
+    }
+    else {
+        intlOptions = {
+            dateStyle: arguments[0],
+            timeStyle: arguments[1],
+            timeZone: arguments[2]?.[0],
+            timeZoneName: arguments[2]?.[1],
+            calendar: arguments[3]
+        };
+    }
+    const locale = inject(LocalizationService, { optional: true })?.get();
+    let intlFormatter;
+    try {
+        intlFormatter = new Intl.DateTimeFormat(locale?.name, intlOptions);
+        return (d) => intlFormatter.format(new Date(d));
+    }
+    catch (err) {
+        console.warn('Invalid date format options:', intlOptions, err);
+        // Return a fallback formatter
+        return (d) => new Date(d).toLocaleString();
+    }
+}
+/**
+ * Creates a locale-based formatter.
+ * @param locale The Locale object.
+ * @param formatterName The format string in the form of "formatterName:param1:param2:..."
+ * @returns A ValueFormatterFunction
+ * @private
+ */
+function createLocaleFormatter(formatterName) {
+    let locale = inject(LocalizationService, { optional: true })?.get();
+    if (locale == null) {
+        throw Error('For using locale formatters, provide a Locale object.');
+    }
+    let formatter = locale.definition.formatters?.[formatterName];
+    let formatterType = typeof formatter;
+    if (!formatter) {
+        console.warn(`The formatter "${formatterName}" is not defined in locale ${locale.definition.name}`);
+        return defaultFormatter;
+    }
+    if (formatterType === 'function') {
+        return formatter;
+    }
+    else if (Array.isArray(formatter)) {
+        return (index) => formatter[+index];
+    }
+    else if (formatterType == 'object' && formatter != null) {
+        return (value) => formatter[value] || '';
+    }
+    else {
+        throw Error(`Invalid locale formatter: ${formatterName}`);
+    }
+}
+/**
+ * Creates a composite formatter that applies multiple formatters in sequence.
+ * @param formatters The list of ObjectFormatterLike values to compose.
+ * @returns An ObjectFormatter function.
+ */
+function createCompositeFormatter(...formatters) {
+    const formattersFuncs = formatters.map(item => createObjectFormatter(item));
+    return (obj) => formattersFuncs.reduce((previous, current, index) => index == 0 ? current(obj) : current(previous));
+}
+/**
+ * Creates an ObjectFormatter from various ObjectFormatterLike types.
+ * @param formatter The ObjectFormatterLike value to convert.
+ * @param locale Optional locale object for locale-based formatting.
+ * @param params Additional parameters for the formatter.
+ * @returns An ObjectFormatter function.
+ */
+function createObjectFormatter(formatter, ...params) {
+    switch (typeof formatter) {
+        case 'function':
+            return formatter.bind(null, ...params);
+        case 'number':
+            return createIndexFormatter(formatter);
+        case 'string':
+            switch (formatter[0]) {
+                case '#':
+                    return createNumberFormatter(...params);
+                case '$':
+                    return createCurrencyFormatter(...params);
+                case '@':
+                    return createDateFormatter(...params);
+                case '*':
+                    return createLocaleFormatter(formatter.substring(1));
+                default:
+                    return createFieldFormatter(formatter);
+            }
+        case 'object':
+            if (Array.isArray(formatter) && formatter.length > 0) {
+                if (formatter[0] == 'C') {
+                    return createCompositeFormatter(formatter.slice(1));
+                }
+                else {
+                    return createObjectFormatter(formatter[0], ...formatter.slice(1));
+                }
+            }
+            break;
+    }
+    throw Error('invalid formatter', { cause: formatter });
+}
+/**
+ * Creates a transform function that converts a ObjectFormatterLike value into a ObjectFormatter.
+ * @param injector The EnvironmentInjector to use for dependency injection.
+ * @returns A function that takes a ObjectFormatterLike and returns a ObjectFormatter.
+ */
+function objectFormatterAttribute(injector) {
+    return (x) => runInInjectionContext(injector, createObjectFormatter.bind(null, x));
+}
+;
+
+class DatePipe {
+    _injector = inject(EnvironmentInjector);
+    transform(value, ...options) {
+        const formatter = runInInjectionContext(this._injector, createDateFormatter.bind(null, ...options));
+        return formatter(value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: DatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.11", ngImport: i0, type: DatePipe, isStandalone: true, name: "ng0Date" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: DatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'ng0Date',
+                    standalone: true,
+                    pure: true
+                }]
+        }] });
+
+class LocalizePipe {
+    _ls;
+    constructor(_ls) {
+        this._ls = _ls;
+    }
+    transform(dictionaryKey) {
+        return this._ls.get()?.translate(dictionaryKey);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: LocalizePipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.11", ngImport: i0, type: LocalizePipe, isStandalone: true, name: "ng0Localize", pure: false });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: LocalizePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'ng0Localize',
+                    standalone: true,
                     pure: false
                 }]
         }], ctorParameters: () => [{ type: LocalizationService }] });
 
-class EnumPipe {
-    _locale;
+class LocalizeEnumPipe {
+    _ls;
     _recompute = true;
     _value;
-    constructor(localeProvider) {
-        this._locale = localeProvider.get();
-        localeProvider.change.pipe(takeUntilDestroyed()).subscribe(x => {
-            this._locale = x.new;
-            this._recompute = true;
-        });
+    constructor(_ls) {
+        this._ls = _ls;
+        _ls.change.pipe(takeUntilDestroyed()).subscribe(x => this._recompute = true);
     }
-    transform(enumValue, ...args) {
+    /**
+     *
+     * @param enumValue
+     * @param enumName
+     * @param nullValueKey
+     * @param returnEnumAsFallback
+     * @param fallbackKey
+     * @returns
+     */
+    transform(enumValue, enumName, fallback) {
         if (this._recompute) {
-            var enumName = args[0];
-            var nullDictionaryKey = args[1];
-            this._value = enumValue ?
-                (this._locale.translateEnum(enumName, enumValue) ?? enumValue) :
-                (nullDictionaryKey ? this._locale.translate(nullDictionaryKey) : '');
+            this._value = this._ls.get()?.translateEnum(enumName, enumValue, fallback);
             this._recompute = false;
         }
         return this._value;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: EnumPipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
-    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.0.6", ngImport: i0, type: EnumPipe, isStandalone: true, name: "ng0Enum", pure: false });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: LocalizeEnumPipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.11", ngImport: i0, type: LocalizeEnumPipe, isStandalone: true, name: "ng0LocalizeEnum", pure: false });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: EnumPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: LocalizeEnumPipe, decorators: [{
             type: Pipe,
             args: [{
-                    name: 'ng0Enum',
+                    name: 'ng0LocalizeEnum',
                     standalone: true,
                     pure: false
                 }]
         }], ctorParameters: () => [{ type: LocalizationService }] });
 
-class BooleanPipe {
-    localeProvider;
-    constructor(localeProvider) {
-        this.localeProvider = localeProvider;
+class LocalizeBooleanPipe {
+    _ls;
+    constructor(_ls) {
+        this._ls = _ls;
     }
     transform(value, falseKey = 'true', trueKey) {
-        return this.localeProvider.get().translate(value ? trueKey : falseKey);
+        return this._ls.get()?.translate(value ? trueKey : falseKey);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: BooleanPipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
-    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.0.6", ngImport: i0, type: BooleanPipe, isStandalone: true, name: "ng0Bool" });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: LocalizeBooleanPipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.11", ngImport: i0, type: LocalizeBooleanPipe, isStandalone: true, name: "ng0LocalizeBool", pure: false });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: BooleanPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: LocalizeBooleanPipe, decorators: [{
             type: Pipe,
             args: [{
-                    name: 'ng0Bool',
+                    name: 'ng0LocalizeBool',
                     standalone: true,
+                    pure: false
                 }]
         }], ctorParameters: () => [{ type: LocalizationService }] });
 
-class DatePipe {
-    _locale;
+class LocalizeDatePipe {
+    _ls;
     _value;
-    constructor(localeProvider) {
-        this._locale = localeProvider.get();
-        localeProvider.change.pipe(takeUntilDestroyed()).subscribe(x => {
-            this._locale = x.new;
-        });
+    _recompute = true;
+    constructor(_ls) {
+        this._ls = _ls;
+        _ls.change.pipe(takeUntilDestroyed()).subscribe(x => this._recompute = true);
     }
-    transform(value) {
-        return this._locale.formatDate(value, '');
+    transform(value, format) {
+        if (this._recompute) {
+            this._value = this._ls.get()?.formatDate(value, format);
+            this._recompute = false;
+        }
+        return this._value;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: DatePipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
-    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.0.6", ngImport: i0, type: DatePipe, isStandalone: true, name: "ng0Date" });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: LocalizeDatePipe, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.11", ngImport: i0, type: LocalizeDatePipe, isStandalone: true, name: "ng0LocalizeDate", pure: false });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: DatePipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: LocalizeDatePipe, decorators: [{
             type: Pipe,
             args: [{
-                    name: 'ng0Date',
-                    standalone: true
+                    name: 'ng0LocalizeDate',
+                    standalone: true,
+                    pure: false
                 }]
         }], ctorParameters: () => [{ type: LocalizationService }] });
 
-const Declarables = [
+/**
+ * Format pipe to format objects using various formatter types.
+ */
+class FormatPipe {
+    _injector = inject(EnvironmentInjector);
+    transform(obj, formatter, ...params) {
+        const frmtFunc = runInInjectionContext(this._injector, createObjectFormatter.bind(null, formatter, ...params));
+        return frmtFunc(obj);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: FormatPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.11", ngImport: i0, type: FormatPipe, isStandalone: true, name: "ng0Format" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: FormatPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'ng0Format',
+                    standalone: true,
+                    pure: true
+                }]
+        }] });
+
+const Declares = [
+    // Pure pipes
     TranslatePipe,
-    EnumPipe,
-    BooleanPipe,
-    DatePipe
+    TranslateEnumPipe,
+    TranslateBooleanPipe,
+    DatePipe,
+    FormatPipe,
+    // Impure pipes
+    LocalizePipe,
+    LocalizeEnumPipe,
+    LocalizeBooleanPipe,
+    LocalizeDatePipe
 ];
 class LocalizationModule {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: LocalizationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.0.6", ngImport: i0, type: LocalizationModule, imports: [CommonModule, TranslatePipe,
-            EnumPipe,
-            BooleanPipe,
-            DatePipe], exports: [TranslatePipe,
-            EnumPipe,
-            BooleanPipe,
-            DatePipe] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: LocalizationModule, imports: [CommonModule] });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: LocalizationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.11", ngImport: i0, type: LocalizationModule, imports: [
+            // Pure pipes
+            TranslatePipe,
+            TranslateEnumPipe,
+            TranslateBooleanPipe,
+            DatePipe,
+            FormatPipe,
+            // Impure pipes
+            LocalizePipe,
+            LocalizeEnumPipe,
+            LocalizeBooleanPipe,
+            LocalizeDatePipe], exports: [
+            // Pure pipes
+            TranslatePipe,
+            TranslateEnumPipe,
+            TranslateBooleanPipe,
+            DatePipe,
+            FormatPipe,
+            // Impure pipes
+            LocalizePipe,
+            LocalizeEnumPipe,
+            LocalizeBooleanPipe,
+            LocalizeDatePipe] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: LocalizationModule });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: LocalizationModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.11", ngImport: i0, type: LocalizationModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [
-                        CommonModule,
-                        Declarables
-                    ],
-                    exports: Declarables
+                    imports: Declares,
+                    exports: Declares
                 }]
         }] });
 
@@ -297,5 +623,5 @@ const LOCALE = new InjectionToken('LOCALE');
  * Generated bundle index. Do not edit.
  */
 
-export { BooleanPipe, DatePipe, EnumPipe, LOCALE, Locale, LocalizationModule, LocalizationService, TranslatePipe };
+export { DatePipe, FormatPipe, LOCALE, Locale, LocalizationModule, LocalizationService, LocalizeBooleanPipe, LocalizeDatePipe, LocalizeEnumPipe, LocalizePipe, TranslateBooleanPipe, TranslateEnumPipe, TranslatePipe, createCompositeFormatter, createCurrencyFormatter, createDateFormatter, createFieldFormatter, createIndexFormatter, createLocaleFormatter, createNumberFormatter, createObjectFormatter, defaultFormatter, objectFormatterAttribute };
 //# sourceMappingURL=bootkit-ng0-localization.mjs.map