@mmstack/translate 21.1.11 → 21.1.13

package/fesm2022/mmstack-translate.mjs

@@ -1,8 +1,9 @@
 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';
+import { inject as inject$1 } from '@angular/core/primitives/di';
 
 const KEY_DELIM = '::MMT_DELIM::';
 function prependDelim(prefix, key) {
@@ -132,9 +133,27 @@ function injectSupportedLocales() {
  * the actual locale signal used to store the current locale string
  */
 const STORE_LOCALE = signal('en-US', ...(ngDevMode ? [{ debugName: "STORE_LOCALE" }] : /* istanbul ignore next */ []));
+/**
+ * @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;
 }
@@ -230,7 +249,7 @@ class TranslationStore {
         messages: this.messages(),
     }, this.cache), ...(ngDevMode ? [{ debugName: "intl" }] : /* istanbul ignore next */ []));
     constructor() {
-        this.locale = initLocale(STORE_LOCALE);
+        this.locale = proxyToGlobalSignleton(initLocale(signal('en-US')));
         const paramName = this.config?.localeParamName;
         if (paramName) {
             const param = pathParam(paramName);
@@ -320,10 +339,10 @@ class TranslationStore {
     hasLocaleLoaders(locale) {
         return Array.from(this.onDemandLoaders.values()).some((loaders) => loaders[locale]);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: TranslationStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: TranslationStore, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: TranslationStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: TranslationStore, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: TranslationStore, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: TranslationStore, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -380,6 +399,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$1(token);
+    return [provider, injectFn];
+}
 
 function unwrap(value) {
     return isSignal(value) ? value() : value;
@@ -407,32 +516,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();
@@ -450,21 +595,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();
@@ -482,21 +654,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();
@@ -523,45 +726,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);
 }
-function formatCurrency(value, currency, opt) {
-    const unwrappedOpt = unwrap(opt);
-    const unwrappedValue = unwrapValue(value, unwrappedOpt?.fallbackToZero);
+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, 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();
@@ -574,16 +883,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 ||
@@ -592,9 +892,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) {
@@ -807,6 +1176,58 @@ function registerRemoteNamespace(ns, defaultTranslation, other) {
         resolveNamespaceTranslation: resolver,
     };
 }
+class UnsafeTKeyMap {
+    map = new Map();
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: UnsafeTKeyMap, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: UnsafeTKeyMap, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.12", 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.
@@ -837,6 +1258,72 @@ function canMatchLocale(prefixSegments = []) {
     };
 }
 
+/**
+ * Provides an isolated mock `TranslationStore` usable across testing modules that use components
+ * depending on `@mmstack/translate` APIs (like `Translate` directive, `Translator` pipe, or `injectNamespaceT`).
+ *
+ * This provider intercepts all translation logic, bypassing chunk loaders and Intl.
+ * When a custom configuration isn't provided, formatMessage simply echoes the translation key, using dots `.`.
+ *
+ * ### Usage
+ * ```typescript
+ * TestBed.configureTestingModule({
+ *   providers: [provideMockTranslations()]
+ * });
+ * ```
+ */
+function provideMockTranslations(options) {
+    // We compile the mock strings to flat delimiters just like the internal compile module.
+    const mappedMocks = {};
+    if (options?.translations) {
+        for (const [namespace, translationObj] of Object.entries(options.translations)) {
+            const compiled = compileTranslation(translationObj, namespace);
+            for (const [key, val] of Object.entries(compiled.flat)) {
+                // e.g. from 'home::MMT_DELIM::title'
+                const fullKey = `${namespace}::MMT_DELIM::${key}`;
+                mappedMocks[fullKey] = val;
+            }
+        }
+    }
+    const locale = options?.locale ?? 'en-US';
+    let intl;
+    if (options?.formatValues) {
+        intl = createIntl({ locale, messages: mappedMocks }, createIntlCache());
+    }
+    return [
+        {
+            provide: TranslationStore,
+            useValue: {
+                locale: signal(locale),
+                formatMessage: (key, values) => {
+                    const message = mappedMocks[key];
+                    if (!message) {
+                        // Fallback to echoing the key back in dot notation (more readable for unit assertions).
+                        return key.replaceAll('::MMT_DELIM::', '.');
+                    }
+                    if (intl) {
+                        return intl.formatMessage({ id: key, defaultMessage: message }, values);
+                    }
+                    return message;
+                },
+                hasLocaleLoaders: () => false,
+                register: () => {
+                    // noop
+                },
+                registerOnDemandLoaders: () => {
+                    // noop
+                },
+                dynamicLocaleLoader: {
+                    isLoading: signal(false),
+                    value: signal(null),
+                    error: signal(null),
+                },
+                loadQueue: signal([]),
+            },
+        },
+    ];
+}
+
 function compareObjects(a, b) {
     if (!a && !b)
         return true;
@@ -875,10 +1362,10 @@ class Translate {
             },
         });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: Translate, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.8", type: Translate, isStandalone: true, inputs: { translate: { classPropertyName: "translate", publicName: "translate", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: Translate, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.12", type: Translate, isStandalone: true, inputs: { translate: { classPropertyName: "translate", publicName: "translate", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImport: i0, type: Translate, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: Translate, decorators: [{
             type: Directive
         }], ctorParameters: () => [], propDecorators: { translate: [{ type: i0.Input, args: [{ isSignal: true, alias: "translate", required: true }] }] } });
 
@@ -906,74 +1393,35 @@ class Translator {
 }
 
 /**
- * Provides an isolated mock `TranslationStore` usable across testing modules that use components
- * depending on `@mmstack/translate` APIs (like `Translate` directive, `Translator` pipe, or `injectNamespaceT`).
+ * 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.
  *
- * This provider intercepts all translation logic, bypassing chunk loaders and Intl.
- * When a custom configuration isn't provided, formatMessage simply echoes the translation key, using dots `.`.
+ * 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.
  *
- * ### Usage
- * ```typescript
- * TestBed.configureTestingModule({
- *   providers: [provideMockTranslations()]
+ * @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 provideMockTranslations(options) {
-    // We compile the mock strings to flat delimiters just like the internal compile module.
-    const mappedMocks = {};
-    if (options?.translations) {
-        for (const [namespace, translationObj] of Object.entries(options.translations)) {
-            const compiled = compileTranslation(translationObj, namespace);
-            for (const [key, val] of Object.entries(compiled.flat)) {
-                // e.g. from 'home::MMT_DELIM::title'
-                const fullKey = `${namespace}::MMT_DELIM::${key}`;
-                mappedMocks[fullKey] = val;
-            }
-        }
-    }
-    const locale = options?.locale ?? 'en-US';
-    let intl;
-    if (options?.formatValues) {
-        intl = createIntl({ locale, messages: mappedMocks }, createIntlCache());
-    }
-    return [
-        {
-            provide: TranslationStore,
-            useValue: {
-                locale: signal(locale),
-                formatMessage: (key, values) => {
-                    const message = mappedMocks[key];
-                    if (!message) {
-                        // Fallback to echoing the key back in dot notation (more readable for unit assertions).
-                        return key.replaceAll('::MMT_DELIM::', '.');
-                    }
-                    if (intl) {
-                        return intl.formatMessage({ id: key, defaultMessage: message }, values);
-                    }
-                    return message;
-                },
-                hasLocaleLoaders: () => false,
-                register: () => {
-                    // noop
-                },
-                registerOnDemandLoaders: () => {
-                    // noop
-                },
-                dynamicLocaleLoader: {
-                    isLoading: signal(false),
-                    value: signal(null),
-                    error: signal(null),
-                },
-                loadQueue: signal([]),
-            },
-        },
-    ];
+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