@mmstack/translate 20.5.11 → 20.5.13

package/index.d.ts

@@ -1,5 +1,6 @@
-import * as i0 from '@angular/core';
-import { Signal, WritableSignal, Provider } from '@angular/core';
+import * as _angular_core from '@angular/core';
+import { Signal, Provider, WritableSignal } from '@angular/core';
+import * as _mmstack_translate from '@mmstack/translate';
 import { ResolveFn, ActivatedRouteSnapshot, CanMatchFn } from '@angular/router';
 import * as _formatjs_intl from '@formatjs/intl';
 import { IntlConfig } from '@formatjs/intl';
@@ -90,7 +91,48 @@ type TranslationNamespace<TNS extends string, T extends CompiledTranslation<Unkn
 };
 declare function createNamespace<const T extends UnknownStringKeyObject, TNS extends string>(ns: TNS, translation: T): TranslationNamespace<TNS, CompiledTranslation<T, TNS, string>, inferTranslationShape<T>>;
 
-declare const FORMAT_PRESETS: Record<string, Intl.DateTimeFormatOptions>;
+declare const FORMAT_PRESETS: {
+    short: {
+        dateStyle: "short";
+        timeStyle: "short";
+    };
+    medium: {
+        dateStyle: "medium";
+        timeStyle: "medium";
+    };
+    long: {
+        dateStyle: "long";
+        timeStyle: "long";
+    };
+    full: {
+        dateStyle: "full";
+        timeStyle: "full";
+    };
+    shortDate: {
+        dateStyle: "short";
+    };
+    mediumDate: {
+        dateStyle: "medium";
+    };
+    longDate: {
+        dateStyle: "long";
+    };
+    fullDate: {
+        dateStyle: "full";
+    };
+    shortTime: {
+        timeStyle: "short";
+    };
+    mediumTime: {
+        timeStyle: "medium";
+    };
+    longTime: {
+        timeStyle: "long";
+    };
+    fullTime: {
+        timeStyle: "full";
+    };
+};
 type DateFormat = keyof typeof FORMAT_PRESETS;
 /**
  * Supported date inputs
@@ -108,21 +150,43 @@ type FormatDateOptions = {
      * Format to use for formatting
      * @default 'medium'
      */
-    format?: DateFormat;
+    format?: DateFormat | Intl.DateTimeFormatOptions;
     /**
-     * Locale to use for formatting, opts out to dynamic locale changes
+     * Locale to use for formatting
      */
+    locale: string;
+};
+/**
+ * @deprecated UNSAFE FOR SSR/EDGE. Omitting the locale property forces a fallback to a process-level global singleton.
+ */
+type UnsafeFormatDateOptions = Omit<FormatDateOptions, 'locale'> & {
+    /** Optional locale string falling back to the legacy global signal */
     locale?: string;
 };
 /**
- * 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
+ * @example formatDate(this.date, this.locale)
+ */
+declare function formatDate(date: SupportedDateInput | Signal<SupportedDateInput>, locale: string | Signal<string>): string;
+/**
+ * @example formatDate(this.date, { locale: 'sl-SI', format: 'shortDate' })
+ */
+declare function formatDate(date: SupportedDateInput | Signal<SupportedDateInput>, opt: FormatDateOptions | Signal<FormatDateOptions>): string;
+/**
+ * @deprecated UNSAFE FOR SSR/EDGE. This signature reads from a process-level global singleton, will be fully removed when Angular 23 drops
+ * Use `injectFormatDate()` instead, or pass locale explicitly.
+ * @example formatDate(this.date)
+ */
+declare function formatDate(date: SupportedDateInput | Signal<SupportedDateInput>, opt?: UnsafeFormatDateOptions | Signal<UnsafeFormatDateOptions>): string;
+declare const provideFormatDateDefaults: (valueOrFn: Omit<Partial<FormatDateOptions>, "locale"> | (() => Omit<Partial<FormatDateOptions>, "locale"> | Signal<Omit<Partial<FormatDateOptions>, "locale">>)) => _angular_core.Provider;
+
+/**
+ * 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()));
  */
-declare function formatDate(date: SupportedDateInput | Signal<SupportedDateInput>, opt?: FormatDateOptions | Signal<FormatDateOptions>): string;
+declare function injectFormatDate(): (date: SupportedDateInput | Signal<SupportedDateInput>, optOrLocale?: Partial<FormatDateOptions> | Signal<Partial<FormatDateOptions>> | string | Signal<string>) => string;
 
 /**
  * Options for formatting a display name
@@ -130,24 +194,46 @@ declare function formatDate(date: SupportedDateInput | Signal<SupportedDateInput
 type FormatDisplayNameOptions = {
     /**
      * The display style for the result set
+     * @default 'long'
      */
-    style: Intl.RelativeTimeFormatStyle;
+    style?: Intl.RelativeTimeFormatStyle;
     /**
-     * Locale to use for formatting, opts out to dynamic locale changes
+     * Locale to use for formatting
      */
+    locale: string;
+};
+/**
+ * @deprecated UNSAFE FOR SSR/EDGE. Omitting the locale property forces a fallback to a process-level global singleton.
+ */
+type UnsafeFormatDisplayNameOptions = Omit<FormatDisplayNameOptions, 'locale'> & {
+    /** Optional locale string falling back to the legacy global signal */
     locale?: string;
 };
 type SupportedCode = string | null | undefined;
 /**
- * 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
+ * @example formatDisplayName(this.value, 'region', this.locale)
+ */
+declare function formatDisplayName(value: SupportedCode | Signal<SupportedCode>, type: Intl.DisplayNamesType | Signal<Intl.DisplayNamesType>, locale: string | Signal<string>): string;
+/**
+ * @example formatDisplayName(this.value, 'region', {locale: 'en-US', style: 'long'})
+ */
+declare function formatDisplayName(value: SupportedCode | Signal<SupportedCode>, type: Intl.DisplayNamesType | Signal<Intl.DisplayNamesType>, opt: FormatDisplayNameOptions | Signal<FormatDisplayNameOptions>): string;
+/**
+ * @deprecated UNSAFE FOR SSR/EDGE. This signature reads from a process-level global singleton, will be fully removed when Angular 23 drops
+ * Use `injectFormatDisplayName()` instead, or pass locale explicitly.
+ * @example formatDisplayName(this.value)
+ */
+declare function formatDisplayName(value: SupportedCode | Signal<SupportedCode>, type: Intl.DisplayNamesType | Signal<Intl.DisplayNamesType>, opt?: UnsafeFormatDisplayNameOptions | Signal<UnsafeFormatDisplayNameOptions>): string;
+declare const provideFormatDisplayNameDefaults: (valueOrFn: Omit<Partial<FormatDisplayNameOptions>, "locale"> | (() => Omit<Partial<FormatDisplayNameOptions>, "locale"> | Signal<Omit<Partial<FormatDisplayNameOptions>, "locale">>)) => _angular_core.Provider;
+
+/**
+ * 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'));
  */
-declare function formatDisplayName(value: SupportedCode | Signal<SupportedCode>, type: Intl.DisplayNamesType | Signal<Intl.DisplayNamesType>, opt?: FormatDisplayNameOptions | Signal<FormatDisplayNameOptions>): string;
+declare function injectFormatDisplayName(): (value: SupportedCode | Signal<SupportedCode>, type: Intl.DisplayNamesType | Signal<Intl.DisplayNamesType>, localeOrOpt?: FormatDisplayNameOptions | Signal<FormatDisplayNameOptions> | string | Signal<string>) => string;
 
 type ListType = 'conjunction' | 'disjunction' | 'unit';
 type ListStyle = 'long' | 'short' | 'narrow';
@@ -158,26 +244,50 @@ type SupportedListInput = string[] | null | undefined;
 type FormatListOptions = {
     /**
      * The type of list to format
+     * @default 'conjunction'
      */
     type?: ListType;
     /**
      * The style of list to format
+     * @default 'long'
      */
     style?: ListStyle;
     /**
-     * Locale to use for formatting, opts out to dynamic locale changes
+     * Locale to use for formatting
      */
+    locale: string;
+};
+/**
+ * @deprecated UNSAFE FOR SSR/EDGE. Omitting the locale property forces a fallback to a process-level global singleton.
+ */
+type UnsafeFormatListOptions = Omit<FormatListOptions, 'locale'> & {
+    /** Optional locale string falling back to the legacy global signal */
     locale?: string;
 };
 /**
- * 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
+ * @example formatList(this.items, this.locale)
+ */
+declare function formatList(value: SupportedListInput | Signal<SupportedListInput>, locale: string | Signal<string>): string;
+/**
+ * @example formatList(this.items, { locale: 'sl-SI', type: 'disjunction' })
+ */
+declare function formatList(value: SupportedListInput | Signal<SupportedListInput>, opt: FormatListOptions | Signal<FormatListOptions>): string;
+/**
+ * @deprecated UNSAFE FOR SSR/EDGE. This signature reads from a process-level global singleton, will be fully removed when Angular 23 drops
+ * Use `injectFormatList()` instead, or pass locale explicitly.
+ * @example formatList(this.items)
  */
-declare function formatList(value: SupportedListInput | Signal<SupportedListInput>, opt?: FormatListOptions | Signal<FormatListOptions>): string;
+declare function formatList(value: SupportedListInput | Signal<SupportedListInput>, opt?: UnsafeFormatListOptions | Signal<UnsafeFormatListOptions>): string;
+declare const provideFormatListDefaults: (valueOrFn: Omit<Partial<FormatListOptions>, "locale"> | (() => Omit<Partial<FormatListOptions>, "locale"> | Signal<Omit<Partial<FormatListOptions>, "locale">>)) => _angular_core.Provider;
+
+/**
+ * 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()));
+ */
+declare function injectFormatList(): (value: SupportedListInput | Signal<SupportedListInput>, optOrLocale?: Partial<FormatListOptions> | Signal<Partial<FormatListOptions>> | string | Signal<string>) => string;
 
 type NumberNotation = 'standard' | 'scientific' | 'engineering' | 'compact';
 type SupportedNumberValue = number | null | undefined;
@@ -187,6 +297,7 @@ type SupportedNumberValue = number | null | undefined;
 type FormatNumberOptions = {
     /**
      * The notation to use for formatting
+     * @default 'standard'
      */
     notation?: NumberNotation;
     /**
@@ -199,27 +310,50 @@ type FormatNumberOptions = {
     maxFractionDigits?: number;
     /**
      * Whether to use grouping
+     * @default true
      */
     useGrouping?: boolean;
-    /**
-     * Locale to use for formatting, opts out to dynamic locale changes
-     */
-    locale?: string;
     /**
      * If the number is not a valid number, return formatted 0. By default formatter returns an empty string
      * @default false
      */
     fallbackToZero?: boolean;
+    /**
+     * Locale to use for formatting
+     */
+    locale: string;
 };
 /**
- * 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
+ * @deprecated UNSAFE FOR SSR/EDGE. Omitting the locale property forces a fallback to a process-level global singleton.
+ */
+type UnsafeFormatNumberOptions = Omit<FormatNumberOptions, 'locale'> & {
+    /** Optional locale string falling back to the legacy global signal */
+    locale?: string;
+};
+/**
+ * @example formatNumber(this.value, this.locale)
+ */
+declare function formatNumber(value: SupportedNumberValue | Signal<SupportedNumberValue>, locale: string | Signal<string>): string;
+/**
+ * @example formatNumber(this.value, { locale: 'de-DE', notation: 'compact' })
  */
-declare function formatNumber(value: SupportedNumberValue | Signal<SupportedNumberValue>, opt?: FormatNumberOptions | Signal<FormatNumberOptions>): string;
+declare function formatNumber(value: SupportedNumberValue | Signal<SupportedNumberValue>, opt: FormatNumberOptions | Signal<FormatNumberOptions>): string;
+/**
+ * @deprecated UNSAFE FOR SSR/EDGE. This signature reads from a process-level global singleton, will be fully removed when Angular 23 drops
+ * Use `injectFormatNumber()` instead, or pass locale explicitly.
+ * @example formatNumber(this.value)
+ */
+declare function formatNumber(value: SupportedNumberValue | Signal<SupportedNumberValue>, opt?: UnsafeFormatNumberOptions | Signal<UnsafeFormatNumberOptions>): string;
+declare const provideFormatNumberDefaults: (valueOrFn: Omit<Partial<FormatNumberOptions>, "locale"> | (() => Omit<Partial<FormatNumberOptions>, "locale"> | Signal<Omit<Partial<FormatNumberOptions>, "locale">>)) => _angular_core.Provider;
+
+/**
+ * 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()));
+ */
+declare function injectFormatNumber(): (value: SupportedNumberValue | Signal<SupportedNumberValue>, optOrLocale?: Partial<FormatNumberOptions> | Signal<Partial<FormatNumberOptions>> | string | Signal<string>) => string;
 /**
  * Options for formatting a percentage value
  */
@@ -232,42 +366,97 @@ type FormatPercentOptions = {
      * Maximum number of fraction digits to use
      */
     maxFractionDigits?: number;
-    /**
-     * Locale to use for formatting, opts out to dynamic locale changes
-     */
-    locale?: string;
     /**
      * If the number is not a valid number, return formatted 0. By default formatter returns an empty string
      * @default false
      */
     fallbackToZero?: boolean;
+    /**
+     * Locale to use for formatting
+     */
+    locale: string;
 };
 /**
- * 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
+ * @deprecated UNSAFE FOR SSR/EDGE. Omitting the locale property forces a fallback to a process-level global singleton.
+ */
+type UnsafeFormatPercentOptions = Omit<FormatPercentOptions, 'locale'> & {
+    /** Optional locale string falling back to the legacy global signal */
+    locale?: string;
+};
+/**
+ * @example formatPercent(this.value, this.locale)
  */
-declare function formatPercent(value: SupportedNumberValue | Signal<SupportedNumberValue>, opt?: FormatPercentOptions | Signal<FormatPercentOptions>): string;
+declare function formatPercent(value: SupportedNumberValue | Signal<SupportedNumberValue>, locale: string | Signal<string>): string;
+/**
+ * @example formatPercent(this.value, { locale: 'de-DE', maxFractionDigits: 2 })
+ */
+declare function formatPercent(value: SupportedNumberValue | Signal<SupportedNumberValue>, opt: FormatPercentOptions | Signal<FormatPercentOptions>): string;
+/**
+ * @deprecated UNSAFE FOR SSR/EDGE. This signature reads from a process-level global singleton, will be fully removed when Angular 23 drops
+ * Use `injectFormatPercent()` instead, or pass locale explicitly.
+ * @example formatPercent(this.value)
+ */
+declare function formatPercent(value: SupportedNumberValue | Signal<SupportedNumberValue>, opt?: UnsafeFormatPercentOptions | Signal<UnsafeFormatPercentOptions>): string;
+declare const provideFormatPercentDefaults: (valueOrFn: Omit<Partial<FormatPercentOptions>, "locale"> | (() => Omit<Partial<FormatPercentOptions>, "locale"> | Signal<Omit<Partial<FormatPercentOptions>, "locale">>)) => _angular_core.Provider;
+
+/**
+ * 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
+ */
+declare function injectFormatPercent(): (value: SupportedNumberValue | Signal<SupportedNumberValue>, optOrLocale?: Partial<FormatPercentOptions> | Signal<Partial<FormatPercentOptions>> | string | Signal<string>) => string;
 type CurrencyDisplay = 'symbol' | 'narrowSymbol' | 'code' | 'name';
 /**
  * Options for formatting a currency
  */
 type FormatCurrencyOptions = {
-    display?: CurrencyDisplay;
     /**
-     * Locale to use for formatting, opts out to dynamic locale changes
+     * The display type for the currency format
+     * @default 'symbol'
      */
-    locale?: string;
+    display?: CurrencyDisplay;
     /**
      * If the number is not a valid number, return formatted 0. By default formatter returns an empty string
      * @default false
      */
     fallbackToZero?: boolean;
+    /**
+     * Locale to use for formatting
+     */
+    locale: string;
+};
+/**
+ * @deprecated UNSAFE FOR SSR/EDGE. Omitting the locale property forces a fallback to a process-level global singleton.
+ */
+type UnsafeFormatCurrencyOptions = Omit<FormatCurrencyOptions, 'locale'> & {
+    /** Optional locale string falling back to the legacy global signal */
+    locale?: string;
 };
-declare function formatCurrency(value: SupportedNumberValue | Signal<SupportedNumberValue>, currency: string | Signal<string>, opt?: FormatCurrencyOptions | Signal<FormatCurrencyOptions>): string;
+/**
+ * @example formatCurrency(this.value, 'USD', this.locale)
+ */
+declare function formatCurrency(value: SupportedNumberValue | Signal<SupportedNumberValue>, currency: string | Signal<string>, locale: string | Signal<string>): string;
+/**
+ * @example formatCurrency(this.value, 'EUR', { locale: 'de-DE', display: 'code' })
+ */
+declare function formatCurrency(value: SupportedNumberValue | Signal<SupportedNumberValue>, currency: string | Signal<string>, opt: FormatCurrencyOptions | Signal<FormatCurrencyOptions>): string;
+/**
+ * @deprecated UNSAFE FOR SSR/EDGE. This signature reads from a process-level global singleton, will be fully removed when Angular 23 drops
+ * Use `injectFormatCurrency()` instead, or pass locale explicitly.
+ * @example formatCurrency(this.value, 'USD')
+ */
+declare function formatCurrency(value: SupportedNumberValue | Signal<SupportedNumberValue>, currency: string | Signal<string>, opt?: UnsafeFormatCurrencyOptions | Signal<UnsafeFormatCurrencyOptions>): string;
+declare const provideFormatCurrencyDefaults: (valueOrFn: Omit<Partial<FormatCurrencyOptions>, "locale"> | (() => Omit<Partial<FormatCurrencyOptions>, "locale"> | Signal<Omit<Partial<FormatCurrencyOptions>, "locale">>)) => _angular_core.Provider;
+
+/**
+ * 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
+ */
+declare function injectFormatCurrency(): (value: SupportedNumberValue | Signal<SupportedNumberValue>, currency: string | Signal<string>, optOrLocale?: Partial<FormatCurrencyOptions> | Signal<Partial<FormatCurrencyOptions>> | string | Signal<string>) => string;
+
+declare function createFormatterProvider<T extends {
+    locale: string;
+}>(formatterName: string, libraryDefaults: Omit<T, 'locale'>, nonLocaleEqual: (a: Omit<T, 'locale'>, b: Omit<T, 'locale'>) => boolean): readonly [(valueOrFn: Omit<Partial<T>, "locale"> | (() => Omit<Partial<T>, "locale"> | Signal<Omit<Partial<T>, "locale">>)) => Provider, () => Signal<T>];
+type inferProvideParameter<T extends ReturnType<typeof createFormatterProvider>[0]> = Parameters<T>[0];
 
 /**
  * Options for formatting a relative time value
@@ -284,22 +473,63 @@ type FormatRelativeTimeOptions = {
      */
     numeric?: Intl.RelativeTimeFormatNumeric;
     /**
-     * Locale to use for formatting, opts out to dynamic locale changes
+     * Locale to use for formatting
      */
+    locale: string;
+};
+/**
+ * @deprecated UNSAFE FOR SSR/EDGE. Omitting the locale property forces a fallback to a process-level global singleton.
+ */
+type UnsafeFormatRelativeTimeOptions = Omit<FormatRelativeTimeOptions, 'locale'> & {
+    /** Optional locale string falling back to the legacy global signal */
     locale?: string;
 };
 type RelativeTimeUnit = Intl.RelativeTimeFormatUnit;
 type SupportedRelativeTimeInput = number | null | undefined;
 /**
- * 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
+ * @example formatRelativeTime(this.value, this.unit, this.locale)
+ */
+declare function formatRelativeTime(value: SupportedRelativeTimeInput | Signal<SupportedRelativeTimeInput>, unit: RelativeTimeUnit | Signal<RelativeTimeUnit>, locale: string | Signal<string>): string;
+/**
+ * @example formatRelativeTime(this.value, 'day', { locale: 'sl-SI', numeric: 'auto' })
  */
-declare function formatRelativeTime(value: SupportedRelativeTimeInput | Signal<SupportedRelativeTimeInput>, unit: RelativeTimeUnit | Signal<RelativeTimeUnit>, opt?: FormatRelativeTimeOptions | Signal<FormatRelativeTimeOptions>): string;
+declare function formatRelativeTime(value: SupportedRelativeTimeInput | Signal<SupportedRelativeTimeInput>, unit: RelativeTimeUnit | Signal<RelativeTimeUnit>, opt: FormatRelativeTimeOptions | Signal<FormatRelativeTimeOptions>): string;
+/**
+ * @deprecated UNSAFE FOR SSR/EDGE. This signature reads from a process-level global singleton, will be fully removed when Angular 23 drops
+ * Use `injectFormatRelativeTime()` instead, or pass locale explicitly.
+ * @example formatRelativeTime(this.value, 'day')
+ */
+declare function formatRelativeTime(value: SupportedRelativeTimeInput | Signal<SupportedRelativeTimeInput>, unit: RelativeTimeUnit | Signal<RelativeTimeUnit>, opt?: UnsafeFormatRelativeTimeOptions | Signal<UnsafeFormatRelativeTimeOptions>): string;
+declare const provideFormatRelativeTimeDefaults: (valueOrFn: Omit<Partial<FormatRelativeTimeOptions>, "locale"> | (() => Omit<Partial<FormatRelativeTimeOptions>, "locale"> | Signal<Omit<Partial<FormatRelativeTimeOptions>, "locale">>)) => _angular_core.Provider;
+
+/**
+ * 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'));
+ */
+declare function injectFormatRelativeTime(): (value: SupportedRelativeTimeInput | Signal<SupportedRelativeTimeInput>, unit: RelativeTimeUnit | Signal<RelativeTimeUnit>, optOrLocale?: Partial<FormatRelativeTimeOptions> | Signal<Partial<FormatRelativeTimeOptions>> | string | Signal<string>) => string;
+
+type FormatDefaults = {
+    date?: inferProvideParameter<typeof provideFormatDateDefaults>;
+    displayName?: inferProvideParameter<typeof provideFormatDisplayNameDefaults>;
+    list?: inferProvideParameter<typeof provideFormatListDefaults>;
+    relativeTime?: inferProvideParameter<typeof provideFormatRelativeTimeDefaults>;
+    number?: inferProvideParameter<typeof provideFormatNumberDefaults>;
+    percent?: inferProvideParameter<typeof provideFormatPercentDefaults>;
+    currency?: inferProvideParameter<typeof provideFormatCurrencyDefaults>;
+};
+declare function provideFormatDefaults(cfg: FormatDefaults): Provider[];
+declare function injectFormatters(): {
+    date: (date: _mmstack_translate.SupportedDateInput | _angular_core.Signal<_mmstack_translate.SupportedDateInput>, optOrLocale?: Partial<_mmstack_translate.FormatDateOptions> | _angular_core.Signal<Partial<_mmstack_translate.FormatDateOptions>> | string | _angular_core.Signal<string>) => string;
+    displayName: (value: (string | null | undefined) | _angular_core.Signal<string | null | undefined>, type: Intl.DisplayNamesType | _angular_core.Signal<Intl.DisplayNamesType>, localeOrOpt?: _mmstack_translate.FormatDisplayNameOptions | _angular_core.Signal<_mmstack_translate.FormatDisplayNameOptions> | string | _angular_core.Signal<string>) => string;
+    list: (value: _mmstack_translate.SupportedListInput | _angular_core.Signal<_mmstack_translate.SupportedListInput>, optOrLocale?: Partial<_mmstack_translate.FormatListOptions> | _angular_core.Signal<Partial<_mmstack_translate.FormatListOptions>> | string | _angular_core.Signal<string>) => string;
+    relativeTime: (value: (number | null | undefined) | _angular_core.Signal<number | null | undefined>, unit: _mmstack_translate.RelativeTimeUnit | _angular_core.Signal<_mmstack_translate.RelativeTimeUnit>, optOrLocale?: Partial<_mmstack_translate.FormatRelativeTimeOptions> | _angular_core.Signal<Partial<_mmstack_translate.FormatRelativeTimeOptions>> | string | _angular_core.Signal<string>) => string;
+    number: (value: (number | null | undefined) | _angular_core.Signal<number | null | undefined>, optOrLocale?: Partial<_mmstack_translate.FormatNumberOptions> | _angular_core.Signal<Partial<_mmstack_translate.FormatNumberOptions>> | string | _angular_core.Signal<string>) => string;
+    percent: (value: (number | null | undefined) | _angular_core.Signal<number | null | undefined>, optOrLocale?: Partial<_mmstack_translate.FormatPercentOptions> | _angular_core.Signal<Partial<_mmstack_translate.FormatPercentOptions>> | string | _angular_core.Signal<string>) => string;
+    currency: (value: (number | null | undefined) | _angular_core.Signal<number | null | undefined>, currency: string | _angular_core.Signal<string>, optOrLocale?: Partial<_mmstack_translate.FormatCurrencyOptions> | _angular_core.Signal<Partial<_mmstack_translate.FormatCurrencyOptions>> | string | _angular_core.Signal<string>) => string;
+};
 
 type BaseConfig = Omit<IntlConfig, 'locale' | 'messages'> & {
     /** Checks next locale is in provided array before switching locales */
@@ -325,6 +555,7 @@ type DynamicConfig = BaseConfig & {
 };
 type Config = RouteBasedConfig | DynamicConfig;
 declare function provideIntlConfig(config: Config): Provider[];
+declare function injectDefaultLocale(): string;
 declare function injectSupportedLocales(): string[];
 declare function injectIntl(): Signal<_formatjs_intl.IntlShape<string>>;
 /**
@@ -373,7 +604,18 @@ type SignalTFunction<TMap extends AnyStringRecord> = <TKey extends keyof TMap &
 type TFunctionWithSignalConstructor<TMap extends AnyStringRecord, TFN extends TFunction<TMap>> = TFN & {
     asSignal: SignalTFunction<TMap>;
 };
-declare function registerNamespace<TDefault extends CompiledTranslation<UnknownStringKeyObject, string>>(defaultTranslation: () => Promise<TDefault>, other: Record<string, () => Promise<CompiledTranslation<UnknownStringKeyObject, inferCompiledTranslationNamespace<TDefault>, string>>>): {
+/**
+ * Shape accepted by a namespace loader: a direct `CompiledTranslation`, or an
+ * ES-module-style object exposing one as `default` or `translation`. Lets
+ * callers write `() => import('./quote.namespace')` instead of the more
+ * verbose `() => import('./quote.namespace').then((m) => m.default)`.
+ */
+type LoadedTranslation<T extends CompiledTranslation<UnknownStringKeyObject, string>> = T | {
+    default: T;
+} | {
+    translation: T;
+};
+declare function registerNamespace<TDefault extends CompiledTranslation<UnknownStringKeyObject, string>>(defaultTranslation: () => Promise<LoadedTranslation<TDefault>>, other: Record<string, () => Promise<LoadedTranslation<CompiledTranslation<UnknownStringKeyObject, inferCompiledTranslationNamespace<TDefault>, string>>>>): {
     injectNamespaceT: () => TFunctionWithSignalConstructor<inferCompiledTranslationMap<TDefault>, TFunction<inferCompiledTranslationMap<TDefault>>>;
     resolveNamespaceTranslation: ResolveFn<void>;
 };
@@ -407,6 +649,9 @@ declare function injectUnsafeT(): {
     asSignal(key: string, params?: () => Record<string, string | number>): Signal<string>;
 };
 
+/**
+ * @internal
+ */
 declare function injectResolveParamLocale(snapshot: ActivatedRouteSnapshot): string;
 
 /**
@@ -484,10 +729,10 @@ declare function provideMockTranslations(options?: MockTranslationOptions): Prov
 
 declare abstract class Translate<TInput extends string, T extends CompiledTranslation<UnknownStringKeyObject, string>, TMap extends inferCompiledTranslationMap<T> = inferCompiledTranslationMap<T>, TKey extends TInput & keyof TMap & string = TInput & keyof TMap & string> {
     private readonly t;
-    readonly translate: i0.InputSignal<TMap[TKey] extends void ? TKey | [key: TKey] : [key: TKey, vars: TMap[TKey]]>;
+    readonly translate: _angular_core.InputSignal<TMap[TKey] extends void ? TKey | [key: TKey] : [key: TKey, vars: TMap[TKey]]>;
     constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<Translate<any, any, any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<Translate<any, any, any, any>, never, never, { "translate": { "alias": "translate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Translate<any, any, any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Translate<any, any, any, any>, never, never, { "translate": { "alias": "translate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 type TransformTFn<T extends CompiledTranslation<UnknownStringKeyObject, string>, TMap extends inferCompiledTranslationMap<T>> = <TKey extends keyof TMap & string>(key: TKey, ...args: TMap[TKey] extends void ? [locale?: string] : [TMap[TKey], locale?: string]) => string;
@@ -521,5 +766,5 @@ declare abstract class Translator<T extends CompiledTranslation<UnknownStringKey
  */
 declare function withParams<const P extends Record<string, unknown>, const S extends string = string>(message: S): WithParams<P, S>;
 
-export { Translate, Translator, canMatchLocale, compileTranslation, createNamespace, formatCurrency, formatDate, formatDisplayName, formatList, formatNumber, formatPercent, formatRelativeTime, injectAddTranslations, injectDynamicLocale, injectIntl, injectResolveParamLocale, injectSupportedLocales, injectUnsafeT, provideIntlConfig, provideMockTranslations, registerNamespace, registerRemoteNamespace, withParams };
-export type { CompiledTranslation, FormatCurrencyOptions, FormatDateOptions, FormatDisplayNameOptions, FormatListOptions, FormatNumberOptions, FormatPercentOptions, FormatRelativeTimeOptions, RelativeTimeUnit, SupportedDateInput, SupportedListInput, inferCompiledTranslationMap, inferCompiledTranslationNamespace, inferCompiledTranslationShape, mergeTranslationMaps };
+export { Translate, Translator, canMatchLocale, compileTranslation, createNamespace, formatCurrency, formatDate, formatDisplayName, formatList, formatNumber, formatPercent, formatRelativeTime, injectAddTranslations, injectDefaultLocale, 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 };
+export type { CompiledTranslation, FormatCurrencyOptions, FormatDateOptions, FormatDisplayNameOptions, FormatListOptions, FormatNumberOptions, FormatPercentOptions, FormatRelativeTimeOptions, RelativeTimeUnit, SupportedDateInput, SupportedListInput, UnsafeFormatCurrencyOptions, UnsafeFormatDateOptions, UnsafeFormatDisplayNameOptions, UnsafeFormatListOptions, UnsafeFormatNumberOptions, UnsafeFormatPercentOptions, UnsafeFormatRelativeTimeOptions, inferCompiledTranslationMap, inferCompiledTranslationNamespace, inferCompiledTranslationShape, mergeTranslationMaps };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmstack/translate",
-  "version": "20.5.11",
+  "version": "20.5.13",
   "keywords": [
     "angular",
     "localize",