@mmstack/translate 19.3.5 → 19.3.7

package/fesm2022/mmstack-translate.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { computed, inject, InjectionToken, LOCALE_ID, signal, isDevMode, effect, resource, untracked, Injectable, isSignal, input, Renderer2, ElementRef, afterRenderEffect, Directive, ChangeDetectorRef } from '@angular/core';
+import { computed, inject, InjectionToken, LOCALE_ID, signal, untracked, isDevMode, effect, resource, Injectable, isSignal, input, Renderer2, ElementRef, afterRenderEffect, Directive, ChangeDetectorRef } from '@angular/core';
 import { createIntlCache, createIntl } from '@formatjs/intl';
 import { toSignal } from '@angular/core/rxjs-interop';
 import { Router, ActivatedRoute } from '@angular/router';
@@ -132,9 +132,27 @@ function injectSupportedLocales() {
  * the actual locale signal used to store the current locale string
  */
 const STORE_LOCALE = signal('en-US');
+/**
+ * @internal
+ * @deprecated will be removed when ng23 drops
+ */
+function readLocaleUnsafe() {
+    return STORE_LOCALE();
+}
 function injectLocaleInternal() {
     return STORE_LOCALE;
 }
+function proxyToGlobalSignleton(src) {
+    const originalSet = src.set;
+    src.set = (next) => {
+        originalSet(next);
+        STORE_LOCALE.set(next);
+    };
+    src.update = (updater) => {
+        src.set(updater(untracked(src)));
+    };
+    return src;
+}
 function isDynamicConfig(cfg) {
     return !!cfg && 'localeStorage' in cfg && !!cfg.localeStorage;
 }
@@ -232,7 +250,7 @@ class TranslationStore {
         messages: this.messages(),
     }, this.cache));
     constructor() {
-        this.locale = initLocale(STORE_LOCALE);
+        this.locale = proxyToGlobalSignleton(initLocale(signal('en-US')));
         const paramName = this.config?.localeParamName;
         if (paramName) {
             const param = pathParam(paramName);
@@ -382,6 +400,96 @@ function injectDynamicLocale() {
     source.isLoading = store.dynamicLocaleLoader.isLoading;
     return source;
 }
+/**
+ * Power-user escape hatch for adding translations imperatively (e.g. content
+ * loaded from a remote API after bootstrap). Returns a function that registers
+ * a flat per-locale map of keys under a given namespace
+ *
+ * Pair with {@link injectUnsafeT} to read the added keys without compile-time
+ * constraints.
+ *
+ * @example
+ * ```ts
+ * const addTranslations = injectAddTranslations();
+ * addTranslations('remote', {
+ *   'en-US': { greeting: 'Hi {name}' },
+ *   'sl-SI': { greeting: 'Zdravo {name}' },
+ * });
+ * ```
+ */
+function injectAddTranslations() {
+    const store = inject(TranslationStore);
+    const supportedLocales = injectIntlConfig()?.supportedLocales;
+    const supportedLocalesSet = supportedLocales
+        ? new Set(supportedLocales)
+        : null;
+    const validate = supportedLocalesSet
+        ? (translations) => {
+            const clean = {};
+            const invalidLocales = [];
+            for (const [locale, translation] of Object.entries(translations)) {
+                if (!supportedLocalesSet.has(locale)) {
+                    invalidLocales.push(locale);
+                    continue;
+                }
+                clean[locale] = translation;
+            }
+            if (isDevMode() && invalidLocales.length > 0)
+                console.warn(`[Translate] Attempted to add translations for unsupported locales: ${invalidLocales.join(', ')}. These translations were ignored. Supported locales are: ${(supportedLocales ?? []).join(', ')}.`);
+            return clean;
+        }
+        : (translations) => translations;
+    return (ns, translations) => {
+        store.register(ns, validate(translations));
+    };
+}
+
+function equalLocale(a, b) {
+    return a.locale === b.locale;
+}
+function createFormatterProvider(formatterName, libraryDefaults, nonLocaleEqual) {
+    const token = new InjectionToken(`@mmstack/translate:format-${formatterName}-config`, {
+        factory: () => {
+            const loc = injectDynamicLocale();
+            return computed(() => ({
+                ...libraryDefaults,
+                locale: loc(),
+            }), { equal: equalLocale });
+        },
+    });
+    const provider = (valueOrFn) => {
+        const fnProvider = typeof valueOrFn === 'function'
+            ? valueOrFn
+            : () => valueOrFn;
+        return {
+            provide: token,
+            useFactory: () => {
+                const loc = injectDynamicLocale();
+                const providedDefaultsOrSignal = fnProvider();
+                if (isSignal(providedDefaultsOrSignal))
+                    return computed(() => ({
+                        ...libraryDefaults,
+                        ...providedDefaultsOrSignal(),
+                        locale: loc(),
+                    }), {
+                        equal: (a, b) => equalLocale(a, b) && nonLocaleEqual(a, b),
+                    });
+                const defaults = {
+                    ...libraryDefaults,
+                    ...providedDefaultsOrSignal,
+                };
+                return computed(() => ({
+                    ...defaults,
+                    locale: loc(),
+                }), {
+                    equal: equalLocale,
+                });
+            },
+        };
+    };
+    const injectFn = () => inject(token);
+    return [provider, injectFn];
+}
 
 function unwrap(value) {
     return isSignal(value) ? value() : value;
@@ -409,32 +517,68 @@ function validDateOrNull(date) {
 }
 const cache$4 = new Map();
 function getFormatter$4(locale, format, timeZone) {
-    const cacheKey = `${locale}|${format}|${timeZone ?? ''}`;
+    const cacheKey = `${locale}|${typeof format === 'string' ? format : JSON.stringify(format)}|${timeZone ?? ''}`;
     let formatter = cache$4.get(cacheKey);
     if (!formatter) {
         formatter = new Intl.DateTimeFormat(locale, {
-            ...FORMAT_PRESETS[format],
+            ...(typeof format === 'string' ? FORMAT_PRESETS[format] : format),
             timeZone,
         });
         cache$4.set(cacheKey, formatter);
     }
     return formatter;
 }
-/**
- * Format a date using the current or provided locale & timezone
- * By default it is reactive to the global dynamic locale, works best when wrapped in a computed() if you need to react to locale changes
- *
- * @param date - Date to format
- * @param opt - Options for formatting
- * @returns Formatted date string
- */
-function formatDate(date, opt) {
+function formatDate(date, optOrLocale) {
     const validDate = validDateOrNull(unwrap(date));
     if (validDate === null)
         return '';
-    const unwrappedOpt = unwrap(opt);
-    const loc = unwrappedOpt?.locale ?? injectLocaleInternal()();
-    return getFormatter$4(loc, unwrappedOpt?.format ?? 'medium', unwrappedOpt?.tz).format(validDate);
+    const unwrappedArgs = unwrap(optOrLocale);
+    let locale;
+    let format = 'medium';
+    let tz;
+    if (typeof unwrappedArgs === 'string') {
+        locale = unwrappedArgs;
+    }
+    else if (unwrappedArgs && typeof unwrappedArgs === 'object') {
+        locale = unwrappedArgs.locale ?? readLocaleUnsafe();
+        format = unwrappedArgs.format ?? 'medium';
+        tz = unwrappedArgs.tz;
+    }
+    else {
+        locale = readLocaleUnsafe();
+    }
+    return getFormatter$4(locale, format, tz).format(validDate);
+}
+const [provideFormatDateDefaults, injectFormatDateOptions] = createFormatterProvider('date', {
+    format: 'medium',
+}, (a, b) => {
+    if (a.tz !== b.tz)
+        return false;
+    if (a.format === b.format)
+        return true;
+    return JSON.stringify(a.format) === JSON.stringify(b.format);
+});
+/**
+ * Inject a context-safe date formatting function tied to the current injector.
+ * Uses the libraries locale signal & provided default configuration to react to locale/config changes
+ * @example
+ * const formatDate = injectFormatDate();
+ * readonly displayDate = computed(() => formatDate(this.date()));
+ */
+function injectFormatDate() {
+    const defaults = injectFormatDateOptions();
+    return (date, optOrLocale) => {
+        if (!optOrLocale)
+            return formatDate(date, defaults());
+        const unwrapped = unwrap(optOrLocale);
+        const opt = typeof unwrapped === 'object'
+            ? { ...defaults(), ...unwrapped }
+            : {
+                ...defaults(),
+                locale: unwrapped,
+            };
+        return formatDate(date, opt);
+    };
 }
 
 const cache$3 = new Map();
@@ -452,21 +596,48 @@ function getFormatter$3(locale, type, style) {
 }
 /**
  * Format a display name using the current or provided locale
- * By default it is reactive to the global dynamic locale, works best when wrapped in a computed() if you need to react to locale changes
  *
  * @param value - The code to format
  * @param type - The type of display name to format
  * @param opt - Options for formatting
  * @returns Formatted display name string
  */
-function formatDisplayName(value, type, opt) {
-    const unwrapped = unwrap(value);
-    if (!unwrapped?.trim())
+function formatDisplayName(value, type, localeOrOpt) {
+    const unwrappedValue = unwrap(value);
+    if (!unwrappedValue?.trim())
         return '';
     const unwrappedType = unwrap(type);
-    const unwrappedOpt = unwrap(opt);
-    const locale = unwrappedOpt?.locale ?? injectLocaleInternal()();
-    return (getFormatter$3(locale, unwrappedType, unwrappedOpt?.style ?? 'long').of(unwrapped) ?? '');
+    const unwrapped = unwrap(localeOrOpt);
+    const locale = typeof unwrapped === 'string'
+        ? unwrapped
+        : (unwrapped?.locale ?? readLocaleUnsafe());
+    const opt = typeof unwrapped === 'object' ? unwrapped : undefined;
+    return (getFormatter$3(locale, unwrappedType, opt?.style ?? 'long').of(unwrappedValue) ?? '');
+}
+const [provideFormatDisplayNameDefaults, injectFormatDisplayNameDefaults] = createFormatterProvider('displayName', {
+    style: 'long',
+}, (a, b) => a.style === b.style);
+/**
+ * Inject a context-safe date formatting function tied to the current injector.
+ * Uses the libraries locale signal & provided default configuration to react to locale/config changes
+ * @example
+ * const formatDisplayName = injectFormatDisplayName();
+ * readonly region = computed(() => formatDisplayName('US', 'region'));
+ */
+function injectFormatDisplayName() {
+    const defaults = injectFormatDisplayNameDefaults();
+    return (value, type, localeOrOpt) => {
+        if (!localeOrOpt)
+            return formatDisplayName(value, type, defaults());
+        const unwrapped = unwrap(localeOrOpt);
+        const opt = typeof unwrapped === 'object'
+            ? { ...defaults, ...unwrapped }
+            : {
+                ...defaults,
+                locale: unwrapped,
+            };
+        return formatDisplayName(value, type, opt);
+    };
 }
 
 const cache$2 = new Map();
@@ -484,21 +655,52 @@ function getFormatter$2(locale, type, style) {
     }
     return formatter;
 }
+function formatList(value, optOrLocale) {
+    const unwrappedValue = unwrapList(value);
+    if (unwrappedValue.length === 0)
+        return '';
+    const unwrappedArgs = unwrap(optOrLocale);
+    let locale;
+    let type = 'conjunction';
+    let style = 'long';
+    if (typeof unwrappedArgs === 'string') {
+        locale = unwrappedArgs;
+    }
+    else if (unwrappedArgs && typeof unwrappedArgs === 'object') {
+        locale = unwrappedArgs.locale ?? readLocaleUnsafe();
+        type = unwrappedArgs.type ?? 'conjunction';
+        style = unwrappedArgs.style ?? 'long';
+    }
+    else {
+        locale = readLocaleUnsafe();
+    }
+    return getFormatter$2(locale, type, style).format(unwrappedValue);
+}
+const [provideFormatListDefaults, injectFormatListOptions] = createFormatterProvider('list', {
+    type: 'conjunction',
+    style: 'long',
+}, (a, b) => a.type === b.type && a.style === b.style);
 /**
- * Format a list using the current or provided locale
- * By default it is reactive to the global dynamic locale, works best when wrapped in a computed() if you need to react to locale changes
- *
- * @param value - The list to format
- * @param opt - Options for formatting
- * @returns Formatted list string
+ * Inject a context-safe list formatting function tied to the current injector.
+ * Uses the libraries locale signal & provided default configuration to react to locale/config changes
+ * @example
+ * const formatList = injectFormatList();
+ * readonly displayList = computed(() => formatList(this.items()));
  */
-function formatList(value, opt) {
-    const unwrapped = unwrapList(value);
-    if (unwrapped.length === 0)
-        return '';
-    const unwrappedOpt = unwrap(opt);
-    const loc = unwrappedOpt?.locale ?? injectLocaleInternal()();
-    return getFormatter$2(loc, unwrappedOpt?.type ?? 'conjunction', unwrappedOpt?.style ?? 'long').format(unwrapped);
+function injectFormatList() {
+    const defaults = injectFormatListOptions();
+    return (value, optOrLocale) => {
+        if (!optOrLocale)
+            return formatList(value, defaults());
+        const unwrapped = unwrap(optOrLocale);
+        const opt = typeof unwrapped === 'object'
+            ? { ...defaults(), ...unwrapped }
+            : {
+                ...defaults(),
+                locale: unwrapped,
+            };
+        return formatList(value, opt);
+    };
 }
 
 const cache$1 = new Map();
@@ -525,45 +727,151 @@ function getFormatter$1(locale, minFractionDigits, maxFractionDigits, useGroupin
     }
     return formatter;
 }
-/**
- * Format a number using the current or provided locale
- * By default it is reactive to the global dynamic locale, works best when wrapped in a computed() if you need to react to locale changes
- *
- * @param number - Number to format
- * @param opt - Options for formatting
- * @returns Formatted number string
- */
-function formatNumber(value, opt) {
-    const unwrappedOpt = unwrap(opt);
-    const unwrappedNumber = unwrapValue(value, unwrappedOpt?.fallbackToZero);
+function formatNumber(value, optOrLocale) {
+    const unwrappedArgs = unwrap(optOrLocale);
+    const isOpt = unwrappedArgs != null && typeof unwrappedArgs === 'object';
+    const fallbackToZero = isOpt ? unwrappedArgs.fallbackToZero : undefined;
+    const unwrappedNumber = unwrapValue(value, fallbackToZero);
     if (unwrappedNumber === null)
         return '';
-    const loc = unwrappedOpt?.locale ?? injectLocaleInternal()();
-    return getFormatter$1(loc, unwrappedOpt?.minFractionDigits, unwrappedOpt?.maxFractionDigits, unwrappedOpt?.useGrouping ?? true, unwrappedOpt?.notation ?? 'standard').format(unwrappedNumber);
+    let locale;
+    let notation;
+    let minFractionDigits;
+    let maxFractionDigits;
+    let useGrouping = true;
+    if (typeof unwrappedArgs === 'string') {
+        locale = unwrappedArgs;
+    }
+    else if (isOpt) {
+        locale = unwrappedArgs.locale ?? readLocaleUnsafe();
+        notation = unwrappedArgs.notation ?? 'standard';
+        minFractionDigits = unwrappedArgs.minFractionDigits;
+        maxFractionDigits = unwrappedArgs.maxFractionDigits;
+        useGrouping = unwrappedArgs.useGrouping ?? true;
+    }
+    else {
+        locale = readLocaleUnsafe();
+        notation = 'standard';
+    }
+    return getFormatter$1(locale, minFractionDigits, maxFractionDigits, useGrouping, notation).format(unwrappedNumber);
 }
+const [provideFormatNumberDefaults, injectFormatNumberOptions] = createFormatterProvider('number', {
+    notation: 'standard',
+    useGrouping: true,
+}, (a, b) => a.notation === b.notation &&
+    a.minFractionDigits === b.minFractionDigits &&
+    a.maxFractionDigits === b.maxFractionDigits &&
+    a.useGrouping === b.useGrouping &&
+    a.fallbackToZero === b.fallbackToZero);
 /**
- * Format a percentage using the current or provided locale
- * By default it is reactive to the global dynamic locale, works best when wrapped in a computed() if you need to react to locale changes
- *
- * @param number - Number to format
- * @param opt - Options for formatting
- * @returns Formatted percentage string
+ * Inject a context-safe number formatting function tied to the current injector.
+ * Uses the libraries locale signal & provided default configuration to react to locale/config changes
+ * @example
+ * const formatNumber = injectFormatNumber();
+ * readonly display = computed(() => formatNumber(this.value()));
  */
-function formatPercent(value, opt) {
-    const unwrappedOpt = unwrap(opt);
-    const unwrappedNumber = unwrapValue(value, unwrappedOpt?.fallbackToZero);
+function injectFormatNumber() {
+    const defaults = injectFormatNumberOptions();
+    return (value, optOrLocale) => {
+        if (!optOrLocale)
+            return formatNumber(value, defaults());
+        const unwrapped = unwrap(optOrLocale);
+        const opt = typeof unwrapped === 'object'
+            ? { ...defaults(), ...unwrapped }
+            : {
+                ...defaults(),
+                locale: unwrapped,
+            };
+        return formatNumber(value, opt);
+    };
+}
+function formatPercent(value, optOrLocale) {
+    const unwrappedArgs = unwrap(optOrLocale);
+    const isOpt = unwrappedArgs != null && typeof unwrappedArgs === 'object';
+    const fallbackToZero = isOpt ? unwrappedArgs.fallbackToZero : undefined;
+    const unwrappedNumber = unwrapValue(value, fallbackToZero);
     if (unwrappedNumber === null)
         return '';
-    const loc = unwrappedOpt?.locale ?? injectLocaleInternal()();
-    return getFormatter$1(loc, unwrappedOpt?.minFractionDigits, unwrappedOpt?.maxFractionDigits, undefined, undefined, undefined, undefined, 'percent').format(unwrappedNumber);
+    let locale;
+    let minFractionDigits;
+    let maxFractionDigits;
+    if (typeof unwrappedArgs === 'string') {
+        locale = unwrappedArgs;
+    }
+    else if (isOpt) {
+        locale = unwrappedArgs.locale ?? readLocaleUnsafe();
+        minFractionDigits = unwrappedArgs.minFractionDigits;
+        maxFractionDigits = unwrappedArgs.maxFractionDigits;
+    }
+    else {
+        locale = readLocaleUnsafe();
+    }
+    return getFormatter$1(locale, minFractionDigits, maxFractionDigits, undefined, undefined, undefined, undefined, 'percent').format(unwrappedNumber);
+}
+const [provideFormatPercentDefaults, injectFormatPercentOptions] = createFormatterProvider('percent', {}, (a, b) => a.minFractionDigits === b.minFractionDigits &&
+    a.maxFractionDigits === b.maxFractionDigits &&
+    a.fallbackToZero === b.fallbackToZero);
+/**
+ * Inject a context-safe percent formatting function tied to the current injector.
+ * Uses the libraries locale signal & provided default configuration to react to locale/config changes
+ */
+function injectFormatPercent() {
+    const defaults = injectFormatPercentOptions();
+    return (value, optOrLocale) => {
+        if (!optOrLocale)
+            return formatPercent(value, defaults());
+        const unwrapped = unwrap(optOrLocale);
+        const opt = typeof unwrapped === 'object'
+            ? { ...defaults(), ...unwrapped }
+            : {
+                ...defaults(),
+                locale: unwrapped,
+            };
+        return formatPercent(value, opt);
+    };
 }
-function formatCurrency(value, currency, opt) {
-    const unwrappedOpt = unwrap(opt);
-    const unwrappedValue = unwrapValue(value, unwrappedOpt?.fallbackToZero);
+function formatCurrency(value, currency, optOrLocale) {
+    const unwrappedArgs = unwrap(optOrLocale);
+    const isOpt = unwrappedArgs != null && typeof unwrappedArgs === 'object';
+    const fallbackToZero = isOpt ? unwrappedArgs.fallbackToZero : undefined;
+    const unwrappedValue = unwrapValue(value, fallbackToZero);
     if (unwrappedValue === null)
         return '';
-    const loc = unwrappedOpt?.locale ?? injectLocaleInternal()();
-    return getFormatter$1(loc, undefined, undefined, undefined, undefined, unwrap(currency), unwrappedOpt?.display ?? 'symbol', 'currency').format(unwrappedValue);
+    let locale;
+    let display = 'symbol';
+    if (typeof unwrappedArgs === 'string') {
+        locale = unwrappedArgs;
+    }
+    else if (isOpt) {
+        locale = unwrappedArgs.locale ?? readLocaleUnsafe();
+        display = unwrappedArgs.display ?? 'symbol';
+    }
+    else {
+        locale = readLocaleUnsafe();
+    }
+    return getFormatter$1(locale, undefined, undefined, undefined, undefined, unwrap(currency), display, 'currency').format(unwrappedValue);
+}
+const [provideFormatCurrencyDefaults, injectFormatCurrencyOptions] = createFormatterProvider('currency', {
+    display: 'symbol',
+}, (a, b) => a.display === b.display && a.fallbackToZero === b.fallbackToZero);
+/**
+ * Inject a context-safe currency formatting function tied to the current injector.
+ * Uses the libraries locale signal & provided default configuration to react to locale/config changes
+ */
+function injectFormatCurrency() {
+    const defaults = injectFormatCurrencyOptions();
+    return (value, currency, optOrLocale) => {
+        if (!optOrLocale)
+            return formatCurrency(value, currency, defaults());
+        const unwrapped = unwrap(optOrLocale);
+        const opt = typeof unwrapped === 'object'
+            ? { ...defaults(), ...unwrapped }
+            : {
+                ...defaults(),
+                locale: unwrapped,
+            };
+        return formatCurrency(value, currency, opt);
+    };
 }
 
 const cache = new Map();
@@ -576,16 +884,7 @@ function getFormatter(locale, style, numeric) {
     }
     return formatter;
 }
-/**
- * Format a relative time using the current or provided locale
- * By default it is reactive to the global dynamic locale, works best when wrapped in a computed() if you need to react to locale changes
- *
- * @param value - The numeric value to use in the relative time internationalization message
- * @param unit - The unit to use in the relative time internationalization message
- * @param opt - Options for formatting
- * @returns Formatted relative time string
- */
-function formatRelativeTime(value, unit, opt) {
+function formatRelativeTime(value, unit, optOrLocale) {
     const unwrappedValue = unwrap(value);
     if (unwrappedValue === null ||
         unwrappedValue === undefined ||
@@ -594,9 +893,78 @@ function formatRelativeTime(value, unit, opt) {
     const unwrappedUnit = unwrap(unit);
     if (!unwrappedUnit)
         return '';
-    const unwrappedOpt = unwrap(opt);
-    const loc = unwrappedOpt?.locale ?? injectLocaleInternal()();
-    return getFormatter(loc, unwrappedOpt?.style ?? 'long', unwrappedOpt?.numeric ?? 'always').format(unwrappedValue, unwrappedUnit);
+    const unwrappedArgs = unwrap(optOrLocale);
+    let locale;
+    let style = 'long';
+    let numeric = 'always';
+    if (typeof unwrappedArgs === 'string') {
+        locale = unwrappedArgs;
+    }
+    else if (unwrappedArgs && typeof unwrappedArgs === 'object') {
+        locale = unwrappedArgs.locale ?? readLocaleUnsafe();
+        style = unwrappedArgs.style ?? 'long';
+        numeric = unwrappedArgs.numeric ?? 'always';
+    }
+    else {
+        locale = readLocaleUnsafe();
+    }
+    return getFormatter(locale, style, numeric).format(unwrappedValue, unwrappedUnit);
+}
+const [provideFormatRelativeTimeDefaults, injectFormatRelativeTimeOptions] = createFormatterProvider('relativeTime', {
+    style: 'long',
+    numeric: 'always',
+}, (a, b) => a.style === b.style && a.numeric === b.numeric);
+/**
+ * Inject a context-safe relative time formatting function tied to the current injector.
+ * Uses the libraries locale signal & provided default configuration to react to locale/config changes
+ * @example
+ * const formatRelativeTime = injectFormatRelativeTime();
+ * readonly relativeAge = computed(() => formatRelativeTime(this.delta(), 'day'));
+ */
+function injectFormatRelativeTime() {
+    const defaults = injectFormatRelativeTimeOptions();
+    return (value, unit, optOrLocale) => {
+        if (!optOrLocale)
+            return formatRelativeTime(value, unit, defaults());
+        const unwrapped = unwrap(optOrLocale);
+        const opt = typeof unwrapped === 'object'
+            ? { ...defaults(), ...unwrapped }
+            : {
+                ...defaults(),
+                locale: unwrapped,
+            };
+        return formatRelativeTime(value, unit, opt);
+    };
+}
+
+function provideFormatDefaults(cfg) {
+    const providers = [];
+    if (cfg.date)
+        providers.push(provideFormatDateDefaults(cfg.date));
+    if (cfg.displayName)
+        providers.push(provideFormatDisplayNameDefaults(cfg.displayName));
+    if (cfg.list)
+        providers.push(provideFormatListDefaults(cfg.list));
+    if (cfg.relativeTime)
+        providers.push(provideFormatRelativeTimeDefaults(cfg.relativeTime));
+    if (cfg.number)
+        providers.push(provideFormatNumberDefaults(cfg.number));
+    if (cfg.percent)
+        providers.push(provideFormatPercentDefaults(cfg.percent));
+    if (cfg.currency)
+        providers.push(provideFormatCurrencyDefaults(cfg.currency));
+    return providers;
+}
+function injectFormatters() {
+    return {
+        date: injectFormatDate(),
+        displayName: injectFormatDisplayName(),
+        list: injectFormatList(),
+        relativeTime: injectFormatRelativeTime(),
+        number: injectFormatNumber(),
+        percent: injectFormatPercent(),
+        currency: injectFormatCurrency(),
+    };
 }
 
 function injectResolveParamLocale(snapshot) {
@@ -809,6 +1177,58 @@ function registerRemoteNamespace(ns, defaultTranslation, other) {
         resolveNamespaceTranslation: resolver,
     };
 }
+class UnsafeTKeyMap {
+    map = new Map();
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: UnsafeTKeyMap, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: UnsafeTKeyMap, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.19", ngImport: i0, type: UnsafeTKeyMap, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+/**
+ * Power-user escape hatch that returns a fully untyped translation function.
+ * Intended for use alongside {@link injectAddTranslations} when translations
+ * are added imperatively (e.g. from a remote API), or for cross-namespace
+ * lookups where the typed API would be impractical.
+ *
+ * @example
+ * ```ts
+ * const t = injectUnsafeT();
+ * t('any.namespace.key', { name: 'Alice', count: 3 });
+ * const sig = t.asSignal('any.namespace.key', () => ({ name: name() }));
+ * ```
+ */
+function injectUnsafeT() {
+    const store = inject(TranslationStore);
+    const map = inject(UnsafeTKeyMap).map;
+    const fn = (key, params) => {
+        let k = map.get(key);
+        if (k === undefined) {
+            k = replaceWithDelim(key);
+            map.set(key, k);
+        }
+        return store.formatMessage(k, params);
+    };
+    fn.asSignal = (key, params) => {
+        let k = map.get(key);
+        if (k === undefined) {
+            k = replaceWithDelim(key);
+            map.set(key, k);
+        }
+        if (!params)
+            return store.buildSimpleKeySignal(k);
+        const paramsSignal = isSignal(params)
+            ? params
+            : computed(() => params(), {
+                equal: createEqualsRecord(Object.keys(params())),
+            });
+        return computed(() => store.formatMessage(k, paramsSignal()));
+    };
+    return fn;
+}
 
 /**
  * Guard that validates the locale parameter against supported locales.
@@ -975,9 +1395,36 @@ class Translator {
     transform = createTransformFn();
 }
 
+/**
+ * Power-user escape hatch for ICU messages whose parameters can't be inferred
+ * from the message string — typically variables nested inside `plural` /
+ * `select` / `selectordinal` arms, which the type-level extractor skips.
+ *
+ * Declared params are merged with auto-extracted ones; on key conflict, the
+ * declared params win. Non-default locales for a key wrapped with `withParams`
+ * may be plain strings — they don't need to repeat the wrapper.
+ *
+ * @example
+ * ```ts
+ * const ns = createNamespace('quote', {
+ *   // auto-extracts `count`; `name` is declared explicitly because it
+ *   // lives inside the plural arms and can't be inferred
+ *   stats: withParams<{ name: string }>(
+ *     '{count, plural, one {1 quote from {name}} other {# quotes from {name}}}',
+ *   ),
+ * });
+ *
+ * // t inferred as: (key, { count: number; name: string }) => string
+ * t('quote.stats', { count: 3, name: 'Alice' });
+ * ```
+ */
+function withParams(message) {
+    return message;
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { Translate, Translator, canMatchLocale, compileTranslation, createNamespace, formatCurrency, formatDate, formatDisplayName, formatList, formatNumber, formatPercent, formatRelativeTime, injectDynamicLocale, injectIntl, injectResolveParamLocale, injectSupportedLocales, provideIntlConfig, provideMockTranslations, registerNamespace, registerRemoteNamespace };
+export { Translate, Translator, canMatchLocale, compileTranslation, createNamespace, formatCurrency, formatDate, formatDisplayName, formatList, formatNumber, formatPercent, formatRelativeTime, injectAddTranslations, injectDynamicLocale, injectFormatCurrency, injectFormatDate, injectFormatDisplayName, injectFormatList, injectFormatNumber, injectFormatPercent, injectFormatRelativeTime, injectFormatters, injectIntl, injectResolveParamLocale, injectSupportedLocales, injectUnsafeT, provideFormatCurrencyDefaults, provideFormatDateDefaults, provideFormatDefaults, provideFormatDisplayNameDefaults, provideFormatListDefaults, provideFormatNumberDefaults, provideFormatPercentDefaults, provideFormatRelativeTimeDefaults, provideIntlConfig, provideMockTranslations, registerNamespace, registerRemoteNamespace, withParams };
 //# sourceMappingURL=mmstack-translate.mjs.map