use-intl 3.25.0 → 4.0.0-beta-00a79d4

package/dist/esm/development/react.js

@@ -0,0 +1,184 @@
+import { createContext, useContext, useMemo, useState, useEffect } from 'react';
+import { d as createCache, b as createIntlFormatters, i as initializeConfig, r as resolveNamespace, I as IntlError, a as IntlErrorCode, e as createBaseTranslator, c as createFormatter } from './initializeConfig-DSmAVNvj.js';
+import { jsx } from 'react/jsx-runtime';
+
+
+
+const IntlContext = /*#__PURE__*/createContext(undefined);
+
+function IntlProvider({
+  children,
+  formats,
+  getMessageFallback,
+  locale,
+  messages,
+  now,
+  onError,
+  timeZone
+}) {
+  const prevContext = useContext(IntlContext);
+
+  // The formatter cache is released when the locale changes. For
+  // long-running apps with a persistent `IntlProvider` at the root,
+  // this can reduce the memory footprint (e.g. in React Native).
+  const cache = useMemo(() => {
+    return prevContext?.cache || createCache();
+  }, [locale, prevContext?.cache]);
+  const formatters = useMemo(() => prevContext?.formatters || createIntlFormatters(cache), [cache, prevContext?.formatters]);
+
+  // Memoizing this value helps to avoid triggering a re-render of all
+  // context consumers in case the configuration didn't change. However,
+  // if some of the non-primitive values change, a re-render will still
+  // be triggered. Note that there's no need to put `memo` on `IntlProvider`
+  // itself, because the `children` typically change on every render.
+  // There's some burden on the consumer side if it's important to reduce
+  // re-renders, put that's how React works.
+  // See: https://blog.isquaredsoftware.com/2020/05/blogged-answers-a-mostly-complete-guide-to-react-rendering-behavior/#context-updates-and-render-optimizations
+  const value = useMemo(() => ({
+    ...initializeConfig({
+      locale,
+      // (required by provider)
+      formats: formats || prevContext?.formats,
+      getMessageFallback: getMessageFallback || prevContext?.getMessageFallback,
+      messages: messages || prevContext?.messages,
+      now: now || prevContext?.now,
+      onError: onError || prevContext?.onError,
+      timeZone: timeZone || prevContext?.timeZone
+    }),
+    formatters,
+    cache
+  }), [cache, formats, formatters, getMessageFallback, locale, messages, now, onError, prevContext, timeZone]);
+  return /*#__PURE__*/jsx(IntlContext.Provider, {
+    value: value,
+    children: children
+  });
+}
+
+function useIntlContext() {
+  const context = useContext(IntlContext);
+  if (!context) {
+    throw new Error('No intl context found. Have you configured the provider? See https://next-intl-docs.vercel.app/docs/usage/configuration#server-client-components' );
+  }
+  return context;
+}
+
+let hasWarnedForMissingTimezone = false;
+const isServer = typeof window === 'undefined';
+function useTranslationsImpl(allMessagesPrefixed, namespacePrefixed, namespacePrefix) {
+  const {
+    cache,
+    formats: globalFormats,
+    formatters,
+    getMessageFallback,
+    locale,
+    onError,
+    timeZone
+  } = useIntlContext();
+
+  // The `namespacePrefix` is part of the type system.
+  // See the comment in the hook invocation.
+  const allMessages = allMessagesPrefixed[namespacePrefix];
+  const namespace = resolveNamespace(namespacePrefixed, namespacePrefix);
+  if (!timeZone && !hasWarnedForMissingTimezone && isServer) {
+    // eslint-disable-next-line react-compiler/react-compiler
+    hasWarnedForMissingTimezone = true;
+    onError(new IntlError(IntlErrorCode.ENVIRONMENT_FALLBACK, `There is no \`timeZone\` configured, this can lead to markup mismatches caused by environment differences. Consider adding a global default: https://next-intl-docs.vercel.app/docs/configuration#time-zone` ));
+  }
+  const translate = useMemo(() => createBaseTranslator({
+    cache,
+    formatters,
+    getMessageFallback,
+    messages: allMessages,
+    namespace,
+    onError,
+    formats: globalFormats,
+    locale,
+    timeZone
+  }), [cache, formatters, getMessageFallback, allMessages, namespace, onError, globalFormats, locale, timeZone]);
+  return translate;
+}
+
+/**
+ * Translates messages from the given namespace by using the ICU syntax.
+ * See https://formatjs.io/docs/core-concepts/icu-syntax.
+ *
+ * If no namespace is provided, all available messages are returned.
+ * The namespace can also indicate nesting by using a dot
+ * (e.g. `namespace.Component`).
+ */
+function useTranslations(namespace) {
+  const context = useIntlContext();
+  const messages = context.messages;
+
+  // We have to wrap the actual hook so the type inference for the optional
+  // namespace works correctly. See https://stackoverflow.com/a/71529575/343045
+  // The prefix ("!") is arbitrary.
+  // @ts-expect-error Use the explicit annotation instead
+  return useTranslationsImpl({
+    '!': messages
+  },
+  // @ts-expect-error
+  namespace ? `!.${namespace}` : '!', '!');
+}
+
+function useLocale() {
+  return useIntlContext().locale;
+}
+
+function getNow() {
+  return new Date();
+}
+
+/**
+ * @see https://next-intl-docs.vercel.app/docs/usage/dates-times#relative-times-usenow
+ */
+function useNow(options) {
+  const updateInterval = options?.updateInterval;
+  const {
+    now: globalNow
+  } = useIntlContext();
+  const [now, setNow] = useState(globalNow || getNow());
+  useEffect(() => {
+    if (!updateInterval) return;
+    const intervalId = setInterval(() => {
+      setNow(getNow());
+    }, updateInterval);
+    return () => {
+      clearInterval(intervalId);
+    };
+  }, [globalNow, updateInterval]);
+  return updateInterval == null && globalNow ? globalNow : now;
+}
+
+function useTimeZone() {
+  return useIntlContext().timeZone;
+}
+
+function useMessages() {
+  const context = useIntlContext();
+  if (!context.messages) {
+    throw new Error('No messages found. Have you configured them correctly? See https://next-intl-docs.vercel.app/docs/configuration#messages' );
+  }
+  return context.messages;
+}
+
+function useFormatter() {
+  const {
+    formats,
+    formatters,
+    locale,
+    now: globalNow,
+    onError,
+    timeZone
+  } = useIntlContext();
+  return useMemo(() => createFormatter({
+    formats,
+    locale,
+    now: globalNow,
+    onError,
+    timeZone,
+    _formatters: formatters
+  }), [formats, formatters, globalNow, locale, onError, timeZone]);
+}
+
+export { IntlProvider, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };

package/dist/esm/production/core.js

@@ -0,0 +1 @@
+import{r as e,e as s,d as r,b as t,f as o,g as n}from"./initializeConfig-BE7tJS3N.js";export{I as IntlError,a as IntlErrorCode,c as createFormatter,i as initializeConfig}from"./initializeConfig-BE7tJS3N.js";function m({_cache:a=r(),_formatters:i=t(a),getMessageFallback:m=o,messages:c,namespace:f,onError:g=n,...l}){return function({messages:a,namespace:r,...t},o){return a=a[o],r=e(r,o),s({...t,messages:a,namespace:r})}({...l,onError:g,cache:a,formatters:i,getMessageFallback:m,messages:{"!":c},namespace:f?`!.${f}`:"!"},"!")}function f(e,a){return e.includes(a)}export{r as _createCache,t as _createIntlFormatters,m as createTranslator,f as hasLocale};

package/dist/esm/production/index.js

@@ -0,0 +1 @@
+export{I as IntlError,a as IntlErrorCode,d as _createCache,b as _createIntlFormatters,c as createFormatter,i as initializeConfig}from"./initializeConfig-BE7tJS3N.js";export{createTranslator,hasLocale}from"./core.js";export{IntlProvider,useFormatter,useLocale,useMessages,useNow,useTimeZone,useTranslations}from"./react.js";

package/dist/esm/production/initializeConfig-BE7tJS3N.js

@@ -0,0 +1 @@
+import{IntlMessageFormat as e}from"intl-messageformat";import{isValidElement as t,cloneElement as r}from"react";import{memoize as n,strategies as o}from"@formatjs/fast-memoize";class a extends Error{constructor(e,t){let r=e;t&&(r+=": "+t),super(r),this.code=e,t&&(this.originalMessage=t)}}var s=function(e){return e.MISSING_MESSAGE="MISSING_MESSAGE",e.MISSING_FORMAT="MISSING_FORMAT",e.ENVIRONMENT_FALLBACK="ENVIRONMENT_FALLBACK",e.INSUFFICIENT_PATH="INSUFFICIENT_PATH",e.INVALID_MESSAGE="INVALID_MESSAGE",e.INVALID_KEY="INVALID_KEY",e.FORMATTING_ERROR="FORMATTING_ERROR",e}(s||{});function i(...e){return e.filter(Boolean).join(".")}function u(e){return i(e.namespace,e.key)}function c(e){console.error(e)}function m(){return{dateTime:{},number:{},message:{},relativeTime:{},pluralRules:{},list:{},displayNames:{}}}function f(e,t){return n(e,{cache:(r=t,{create:()=>({get:e=>r[e],set(e,t){r[e]=t}})}),strategy:o.variadic});var r}function l(e,t){return f(((...t)=>new e(...t)),t)}function g(e){return{getDateTimeFormat:l(Intl.DateTimeFormat,e.dateTime),getNumberFormat:l(Intl.NumberFormat,e.number),getPluralRules:l(Intl.PluralRules,e.pluralRules),getRelativeTimeFormat:l(Intl.RelativeTimeFormat,e.relativeTime),getListFormat:l(Intl.ListFormat,e.list),getDisplayNames:l(Intl.DisplayNames,e.displayNames)}}function I(e,t,r,n){const o=i(n,r);if(!t)throw new Error(o);let a=t;return r.split(".").forEach((t=>{const r=a[t];if(null==t||null==r)throw new Error(o+` (${e})`);a=r})),a}function E(n){const o=function(e,t,r,n=c){try{if(!t)throw new Error(void 0);const n=r?I(e,t,r):t;if(!n)throw new Error(r);return n}catch(e){const t=new a(s.MISSING_MESSAGE,e.message);return n(t),t}}(n.locale,n.messages,n.namespace,n.onError);return function({cache:n,formats:o,formatters:i,getMessageFallback:c=u,locale:m,messagesOrError:l,namespace:g,onError:E,timeZone:S}){const T=l instanceof a;function N(e,t,r){const n=new a(t,r);return E(n),c({error:n,key:e,namespace:g})}function y(a,u,E){if(T)return c({error:l,key:a,namespace:g});const y=l;let A,M;try{A=I(m,y,a,g)}catch(e){return N(a,s.MISSING_MESSAGE,e.message)}if("object"==typeof A){let e,t;return e=Array.isArray(A)?s.INVALID_MESSAGE:s.INSUFFICIENT_PATH,N(a,e,t)}const F=function(e,t){return t?void 0:e}(A,u);if(F)return F;i.getMessageFormat||(i.getMessageFormat=function(t,r){return f(((...t)=>new e(t[0],t[1],t[2],{formatters:r,...t[3]})),t.message)}(n,i));try{M=i.getMessageFormat(A,m,function(t,r,n){const o=e.formats.date,a=e.formats.time,s={...t?.dateTime,...r?.dateTime},i={date:{...o,...s},time:{...a,...s},number:{...t?.number,...r?.number}};return n&&["date","time"].forEach((e=>{const t=i[e];for(const[e,r]of Object.entries(t))t[e]={timeZone:n,...r}})),i}(o,E,S),{formatters:{...i,getDateTimeFormat:(e,t)=>i.getDateTimeFormat(e,{timeZone:S,...t})}})}catch(e){const t=e;return N(a,s.INVALID_MESSAGE,t.message)}try{const e=M.format(u?function(e){const n={};return Object.keys(e).forEach((o=>{let a=0;const s=e[o];let i;i="function"==typeof s?e=>{const n=s(e);return t(n)?r(n,{key:o+a++}):n}:s,n[o]=i})),n}(u):u);if(null==e)throw new Error(void 0);return t(e)||Array.isArray(e)||"string"==typeof e?e:String(e)}catch(e){return N(a,s.FORMATTING_ERROR,e.message)}}function A(e,t,r){const n=y(e,t,r);return"string"!=typeof n?N(e,s.INVALID_MESSAGE,void 0):n}return A.rich=y,A.markup=(e,t,r)=>y(e,t,r),A.raw=e=>{if(T)return c({error:l,key:e,namespace:g});const t=l;try{return I(m,t,e,g)}catch(t){return N(e,s.MISSING_MESSAGE,t.message)}},A.has=e=>{if(T)return!1;try{return I(m,l,e,g),!0}catch{return!1}},A}({...n,messagesOrError:o})}function S(e,t){return e===t?void 0:e.slice((t+".").length)}const T=3600,N=86400,y=7*N,A=2628e3,M=7884e3,F=365*N,R={second:1,seconds:1,minute:60,minutes:60,hour:T,hours:T,day:N,days:N,week:y,weeks:y,month:A,months:A,quarter:M,quarters:M,year:F,years:F};function h(e){const{_cache:t=m(),_formatters:r=g(t),formats:n,locale:o,onError:i=c,timeZone:u}=e;function f(e){return e?.timeZone||(u?e={...e,timeZone:u}:i(new a(s.ENVIRONMENT_FALLBACK,void 0))),e}function l(e,t,r,n){let o;try{o=function(e,t){let r;if("string"==typeof t){const n=t;if(r=e?.[n],!r){const e=new a(s.MISSING_FORMAT,void 0);throw i(e),e}}else r=t;return r}(t,e)}catch{return n()}try{return r(o)}catch(e){return i(new a(s.FORMATTING_ERROR,e.message)),n()}}function I(e,t){return l(t,n?.dateTime,(t=>(t=f(t),r.getDateTimeFormat(o,t).format(e))),(()=>String(e)))}function E(){return e.now?e.now:(i(new a(s.ENVIRONMENT_FALLBACK,void 0)),new Date)}return{dateTime:I,number:function(e,t){return l(t,n?.number,(t=>r.getNumberFormat(o,t).format(e)),(()=>String(e)))},relativeTime:function(e,t){try{let n,a;const s={};t instanceof Date||"number"==typeof t?n=new Date(t):t&&(n=null!=t.now?new Date(t.now):E(),a=t.unit,s.style=t.style,s.numberingSystem=t.numberingSystem),n||(n=E());const i=(new Date(e).getTime()-n.getTime())/1e3;a||(a=function(e){const t=Math.abs(e);return t<60?"second":t<T?"minute":t<N?"hour":t<y?"day":t<A?"week":t<F?"month":"year"}(i)),s.numeric="second"===a?"auto":"always";const u=function(e,t){return Math.round(e/R[t])}(i,a);return r.getRelativeTimeFormat(o,s).format(u,a)}catch(t){return i(new a(s.FORMATTING_ERROR,t.message)),String(e)}},list:function(e,t){const a=[],s=new Map;let i=0;for(const t of e){let e;"object"==typeof t?(e=String(i),s.set(e,t)):e=String(t),a.push(e),i++}return l(t,n?.list,(e=>{const t=r.getListFormat(o,e).formatToParts(a).map((e=>"literal"===e.type?e.value:s.get(e.value)||e.value));return s.size>0?t:t.join("")}),(()=>String(e)))},dateTimeRange:function(e,t,a){return l(a,n?.dateTime,(n=>(n=f(n),r.getDateTimeFormat(o,n).formatRange(e,t))),(()=>[I(e),I(t)].join(" – ")))}}}function w({getMessageFallback:e,messages:t,onError:r,...n}){return{...n,messages:t,onError:r||c,getMessageFallback:e||u}}export{a as I,s as a,g as b,h as c,m as d,E as e,u as f,c as g,w as i,S as r};

package/dist/esm/production/react.js

@@ -0,0 +1 @@
+import{createContext as e,useContext as r,useMemo as o,useState as t,useEffect as n}from"react";import{d as a,b as s,i as c,r as i,I as m,a as f,e as l,c as u}from"./initializeConfig-BE7tJS3N.js";import{jsx as g}from"react/jsx-runtime";const w=e(void 0);function d({children:e,formats:t,getMessageFallback:n,locale:i,messages:m,now:f,onError:l,timeZone:u}){const d=r(w),E=o((()=>d?.cache||a()),[i,d?.cache]),h=o((()=>d?.formatters||s(E)),[E,d?.formatters]),p=o((()=>({...c({locale:i,formats:t||d?.formats,getMessageFallback:n||d?.getMessageFallback,messages:m||d?.messages,now:f||d?.now,onError:l||d?.onError,timeZone:u||d?.timeZone}),formatters:h,cache:E})),[E,t,h,n,i,m,f,l,d,u]);return g(w.Provider,{value:p,children:e})}function E(){const e=r(w);if(!e)throw new Error(void 0);return e}let h=!1;const p="undefined"==typeof window;function v(e){return function(e,r,t){const{cache:n,formats:a,formatters:s,getMessageFallback:c,locale:u,onError:g,timeZone:w}=E(),d=e[t],v=i(r,t);return w||h||!p||(h=!0,g(new m(f.ENVIRONMENT_FALLBACK,void 0))),o((()=>l({cache:n,formatters:s,getMessageFallback:c,messages:d,namespace:v,onError:g,formats:a,locale:u,timeZone:w})),[n,s,c,d,v,g,a,u,w])}({"!":E().messages},e?`!.${e}`:"!","!")}function Z(){return E().locale}function b(){return new Date}function F(e){const r=e?.updateInterval,{now:o}=E(),[a,s]=t(o||b());return n((()=>{if(!r)return;const e=setInterval((()=>{s(b())}),r);return()=>{clearInterval(e)}}),[o,r]),null==r&&o?o:a}function M(){return E().timeZone}function k(){const e=E();if(!e.messages)throw new Error(void 0);return e.messages}function I(){const{formats:e,formatters:r,locale:t,now:n,onError:a,timeZone:s}=E();return o((()=>u({formats:e,locale:t,now:n,onError:a,timeZone:s,_formatters:r})),[e,r,n,t,a,s])}export{d as IntlProvider,I as useFormatter,Z as useLocale,k as useMessages,F as useNow,M as useTimeZone,v as useTranslations};

package/dist/types/{src/core → core}/AbstractIntlMessages.d.ts

@@ -1,6 +1,7 @@
-/** A generic type that describes the shape of messages.
+/**
+ * A generic type that describes the shape of messages.
  *
- * Optionally `IntlMessages` can be provided to get type safety for message
+ * Optionally, messages can be strictly-typed in order to get type safety for message
  * namespaces and keys. See https://next-intl-docs.vercel.app/docs/usage/typescript
  */
 type AbstractIntlMessages = {

package/dist/types/core/AppConfig.d.ts

@@ -0,0 +1,25 @@
+export default interface AppConfig {
+}
+export type Locale = AppConfig extends {
+    Locale: infer AppLocale;
+} ? AppLocale : string;
+export type FormatNames = AppConfig extends {
+    Formats: infer AppFormats;
+} ? {
+    dateTime: AppFormats extends {
+        dateTime: infer AppDateTimeFormats;
+    } ? keyof AppDateTimeFormats : string;
+    number: AppFormats extends {
+        number: infer AppNumberFormats;
+    } ? keyof AppNumberFormats : string;
+    list: AppFormats extends {
+        list: infer AppListFormats;
+    } ? keyof AppListFormats : string;
+} : {
+    dateTime: string;
+    number: string;
+    list: string;
+};
+export type Messages = AppConfig extends {
+    Messages: infer AppMessages;
+} ? AppMessages : Record<string, any>;

package/dist/types/{src/core → core}/DateTimeFormatOptions.d.ts

@@ -1,4 +1,4 @@
-import TimeZone from './TimeZone';
+import type TimeZone from './TimeZone.tsx';
 /**
  * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat
  */

package/dist/types/{src/core → core}/Formats.d.ts

@@ -1,5 +1,5 @@
-import DateTimeFormatOptions from './DateTimeFormatOptions';
-import NumberFormatOptions from './NumberFormatOptions';
+import type DateTimeFormatOptions from './DateTimeFormatOptions.tsx';
+import type NumberFormatOptions from './NumberFormatOptions.tsx';
 type Formats = {
     number?: Record<string, NumberFormatOptions>;
     dateTime?: Record<string, DateTimeFormatOptions>;

package/dist/types/core/ICUArgs.d.ts

@@ -0,0 +1,3 @@
+import type { GetICUArgs, GetICUArgsOptions } from '@schummar/icu-type-parser';
+type ICUArgs<Message extends string, Options extends GetICUArgsOptions> = string extends Message ? {} : GetICUArgs<Message, Options>;
+export default ICUArgs;

package/dist/types/core/ICUTags.d.ts

@@ -0,0 +1,2 @@
+type ICUTags<MessageString extends string, TagsFn> = MessageString extends `${infer Prefix}<${infer TagName}>${infer Content}</${string}>${infer Tail}` ? Record<TagName, TagsFn> & ICUTags<`${Prefix}${Content}${Tail}`, TagsFn> : {};
+export default ICUTags;

package/dist/types/{src/core → core}/IntlConfig.d.ts

@@ -1,14 +1,14 @@
-import type AbstractIntlMessages from './AbstractIntlMessages';
-import type Formats from './Formats';
-import type IntlError from './IntlError';
-import type TimeZone from './TimeZone';
-import type { RichTranslationValues } from './TranslationValues';
+import type AbstractIntlMessages from './AbstractIntlMessages.tsx';
+import type { Locale } from './AppConfig.tsx';
+import type Formats from './Formats.tsx';
+import type IntlError from './IntlError.tsx';
+import type TimeZone from './TimeZone.tsx';
 /**
  * Should be used for entry points that configure the library.
  */
 type IntlConfig<Messages = AbstractIntlMessages> = {
     /** A valid Unicode locale tag (e.g. "en" or "en-GB"). */
-    locale: string;
+    locale: Locale;
     /** Global formats can be provided to achieve consistent
      * formatting across components. */
     formats?: Formats;
@@ -39,13 +39,6 @@ type IntlConfig<Messages = AbstractIntlMessages> = {
     now?: Date;
     /** All messages that will be available. */
     messages?: Messages;
-    /** Global default values for translation values and rich text elements.
-     * Can be used for consistent usage or styling of rich text elements.
-     * Defaults will be overidden by locally provided values.
-     *
-     * @deprecated See https://next-intl-docs.vercel.app/docs/usage/messages#rich-text-reuse-tags
-     **/
-    defaultTranslationValues?: RichTranslationValues;
 };
 /**
  * A stricter set of the configuration that should be used internally

package/dist/types/core/IntlError.d.ts

@@ -0,0 +1,6 @@
+import type IntlErrorCode from './IntlErrorCode.tsx';
+export default class IntlError extends Error {
+    readonly code: IntlErrorCode;
+    readonly originalMessage: string | undefined;
+    constructor(code: IntlErrorCode, originalMessage?: string);
+}

package/dist/types/{src/core/IntlError.d.ts → core/IntlErrorCode.d.ts}

@@ -1,4 +1,4 @@
-export declare enum IntlErrorCode {
+declare const enum IntlErrorCode {
     MISSING_MESSAGE = "MISSING_MESSAGE",
     MISSING_FORMAT = "MISSING_FORMAT",
     ENVIRONMENT_FALLBACK = "ENVIRONMENT_FALLBACK",
@@ -7,8 +7,4 @@ export declare enum IntlErrorCode {
     INVALID_KEY = "INVALID_KEY",
     FORMATTING_ERROR = "FORMATTING_ERROR"
 }
-export default class IntlError extends Error {
-    readonly code: IntlErrorCode;
-    readonly originalMessage: string | undefined;
-    constructor(code: IntlErrorCode, originalMessage?: string);
-}
+export default IntlErrorCode;

package/dist/types/core/MessageKeys.d.ts

@@ -0,0 +1,10 @@
+export type NestedKeyOf<ObjectType> = ObjectType extends object ? {
+    [Property in keyof ObjectType]: `${Property & string}` | `${Property & string}.${NestedKeyOf<ObjectType[Property]>}`;
+}[keyof ObjectType] : never;
+export type NestedValueOf<ObjectType, Path extends string> = Path extends `${infer Cur}.${infer Rest}` ? Cur extends keyof ObjectType ? NestedValueOf<ObjectType[Cur], Rest> : never : Path extends keyof ObjectType ? ObjectType[Path] : never;
+export type NamespaceKeys<ObjectType, AllKeys extends string> = {
+    [PropertyPath in AllKeys]: NestedValueOf<ObjectType, PropertyPath> extends string ? never : PropertyPath;
+}[AllKeys];
+export type MessageKeys<ObjectType, AllKeys extends string> = {
+    [PropertyPath in AllKeys]: NestedValueOf<ObjectType, PropertyPath> extends string ? PropertyPath : never;
+}[AllKeys];

package/dist/types/core/TranslationValues.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+export type ICUArg = string | number | boolean | Date;
+export type ICUNumber = number;
+export type ICUDate = Date | number | string;
+export type TranslationValues = Record<string, ICUArg>;
+export type RichTagsFunction = (chunks: ReactNode) => ReactNode;
+export type MarkupTagsFunction = (chunks: string) => string;
+export type RichTranslationValues = Record<string, ICUArg | RichTagsFunction>;
+export type MarkupTranslationValues = Record<string, ICUArg | MarkupTagsFunction>;

package/dist/types/{src/core → core}/convertFormatsToIntlMessageFormat.d.ts

@@ -1,6 +1,6 @@
-import { Formats as IntlFormats } from 'intl-messageformat';
-import Formats from './Formats';
-import TimeZone from './TimeZone';
+import { type Formats as IntlFormats } from 'intl-messageformat';
+import type Formats from './Formats.tsx';
+import type TimeZone from './TimeZone.tsx';
 /**
  * `intl-messageformat` uses separate keys for `date` and `time`, but there's
  * only one native API: `Intl.DateTimeFormat`. Additionally you might want to
@@ -8,4 +8,4 @@ import TimeZone from './TimeZone';
  * seem so useful. We offer a single `dateTime` namespace instead, but we have
  * to convert the format before `intl-messageformat` can be used.
  */
-export default function convertFormatsToIntlMessageFormat(formats: Formats, timeZone?: TimeZone): Partial<IntlFormats>;
+export default function convertFormatsToIntlMessageFormat(globalFormats?: Formats, inlineFormats?: Formats, timeZone?: TimeZone): Partial<IntlFormats>;

package/dist/types/{src/core → core}/createBaseTranslator.d.ts

@@ -1,17 +1,14 @@
-import { ReactNode } from 'react';
-import AbstractIntlMessages from './AbstractIntlMessages';
-import Formats from './Formats';
-import { InitializedIntlConfig } from './IntlConfig';
-import IntlError from './IntlError';
-import TranslationValues, { MarkupTranslationValues, RichTranslationValues } from './TranslationValues';
-import { Formatters, IntlCache } from './formatters';
-import MessageKeys from './utils/MessageKeys';
-import NestedKeyOf from './utils/NestedKeyOf';
-import NestedValueOf from './utils/NestedValueOf';
+import { type ReactNode } from 'react';
+import type AbstractIntlMessages from './AbstractIntlMessages.tsx';
+import type Formats from './Formats.tsx';
+import type { InitializedIntlConfig } from './IntlConfig.tsx';
+import IntlError from './IntlError.tsx';
+import type { MessageKeys, NestedKeyOf, NestedValueOf } from './MessageKeys.tsx';
+import type { MarkupTranslationValues, RichTranslationValues, TranslationValues } from './TranslationValues.tsx';
+import { type Formatters, type IntlCache } from './formatters.tsx';
 export type CreateBaseTranslatorProps<Messages> = InitializedIntlConfig & {
     cache: IntlCache;
     formatters: Formatters;
-    defaultTranslationValues?: RichTranslationValues;
     namespace?: string;
     messagesOrError: Messages | IntlError;
 };
@@ -20,5 +17,5 @@ export default function createBaseTranslator<Messages extends AbstractIntlMessag
     rich: (key: string, values?: RichTranslationValues, formats?: Formats) => ReactNode;
     markup(key: Parameters<(key: string, values?: RichTranslationValues, formats?: Formats) => ReactNode>[0], values: MarkupTranslationValues, formats?: Parameters<(key: string, values?: RichTranslationValues, formats?: Formats) => ReactNode>[2]): string;
     raw(key: string): any;
-    has(key: Parameters<(key: string, values?: RichTranslationValues, formats?: Formats) => ReactNode>[0]): boolean;
+    has(key: string): boolean;
 };

package/dist/types/core/createFormatter.d.ts

@@ -0,0 +1,28 @@
+import type { ReactElement } from 'react';
+import type { FormatNames, Locale } from './AppConfig.tsx';
+import type DateTimeFormatOptions from './DateTimeFormatOptions.tsx';
+import type Formats from './Formats.tsx';
+import IntlError from './IntlError.tsx';
+import type NumberFormatOptions from './NumberFormatOptions.tsx';
+import type RelativeTimeFormatOptions from './RelativeTimeFormatOptions.tsx';
+import type TimeZone from './TimeZone.tsx';
+import { type Formatters, type IntlCache } from './formatters.tsx';
+type Props = {
+    locale: Locale;
+    timeZone?: TimeZone;
+    onError?(error: IntlError): void;
+    formats?: Formats;
+    now?: Date;
+    /** @private */
+    _formatters?: Formatters;
+    /** @private */
+    _cache?: IntlCache;
+};
+export default function createFormatter(props: Props): {
+    dateTime: (value: Date | number, formatOrOptions?: FormatNames["dateTime"] | DateTimeFormatOptions) => string;
+    number: (value: number | bigint, formatOrOptions?: FormatNames["number"] | NumberFormatOptions) => string;
+    relativeTime: (date: number | Date, nowOrOptions?: RelativeTimeFormatOptions["now"] | RelativeTimeFormatOptions) => string;
+    list: <Value extends string | ReactElement<any, string | import("react").JSXElementConstructor<any>>>(value: Iterable<Value>, formatOrOptions?: FormatNames["list"] | Intl.ListFormatOptions) => Value extends string ? string : Iterable<ReactElement>;
+    dateTimeRange: (start: Date | number, end: Date | number, formatOrOptions?: FormatNames["dateTime"] | DateTimeFormatOptions) => string;
+};
+export {};

package/dist/types/core/createTranslator.d.ts

@@ -0,0 +1,52 @@
+import type { ReactNode } from 'react';
+import type { Messages } from './AppConfig.tsx';
+import type Formats from './Formats.tsx';
+import type ICUArgs from './ICUArgs.tsx';
+import type ICUTags from './ICUTags.tsx';
+import type IntlConfig from './IntlConfig.tsx';
+import type { MessageKeys, NamespaceKeys, NestedKeyOf, NestedValueOf } from './MessageKeys.tsx';
+import type { ICUArg, ICUDate, ICUNumber, MarkupTagsFunction, RichTagsFunction } from './TranslationValues.tsx';
+import { type Formatters, type IntlCache } from './formatters.tsx';
+import type { Prettify } from './types.tsx';
+type ICUArgsWithTags<MessageString extends string, TagsFn extends RichTagsFunction | MarkupTagsFunction = never> = ICUArgs<MessageString, {
+    ICUArgument: ICUArg;
+    ICUNumberArgument: ICUNumber;
+    ICUDateArgument: ICUDate;
+}> & ([TagsFn] extends [never] ? {} : ICUTags<MessageString, TagsFn>);
+type OnlyOptional<T> = Partial<T> extends T ? true : false;
+type TranslateArgs<Value extends string, TagsFn extends RichTagsFunction | MarkupTagsFunction = never> = string extends Value ? [values?: Record<string, ICUArg | TagsFn>, formats?: Formats] : (Value extends any ? (key: ICUArgsWithTags<Value, TagsFn>) => void : never) extends (key: infer Args) => void ? OnlyOptional<Args> extends true ? [values?: undefined, formats?: Formats] : [values: Prettify<Args>, formats?: Formats] : never;
+type NamespacedMessageKeys<TranslatorMessages extends Messages, Namespace extends NamespaceKeys<TranslatorMessages, NestedKeyOf<TranslatorMessages>> = never> = MessageKeys<NestedValueOf<{
+    '!': TranslatorMessages;
+}, [
+    Namespace
+] extends [never] ? '!' : `!.${Namespace}`>, NestedKeyOf<NestedValueOf<{
+    '!': TranslatorMessages;
+}, [
+    Namespace
+] extends [never] ? '!' : `!.${Namespace}`>>>;
+type NamespacedValue<TranslatorMessages extends Messages, Namespace extends NamespaceKeys<TranslatorMessages, NestedKeyOf<TranslatorMessages>>, TargetKey extends NamespacedMessageKeys<TranslatorMessages, Namespace>> = NestedValueOf<TranslatorMessages, [
+    Namespace
+] extends [never] ? TargetKey : `${Namespace}.${TargetKey}`>;
+/**
+ * Translates messages from the given namespace by using the ICU syntax.
+ * See https://formatjs.io/docs/core-concepts/icu-syntax.
+ *
+ * If no namespace is provided, all available messages are returned.
+ * The namespace can also indicate nesting by using a dot
+ * (e.g. `namespace.Component`).
+ */
+export default function createTranslator<const TranslatorMessages extends Messages = Messages, const Namespace extends NamespaceKeys<TranslatorMessages, NestedKeyOf<TranslatorMessages>> = never>({ _cache, _formatters, getMessageFallback, messages, namespace, onError, ...rest }: Omit<IntlConfig<TranslatorMessages>, 'messages'> & {
+    messages?: TranslatorMessages;
+    namespace?: Namespace;
+    /** @private */
+    _formatters?: Formatters;
+    /** @private */
+    _cache?: IntlCache;
+}): {
+    <TargetKey extends NamespacedMessageKeys<TranslatorMessages, Namespace>>(key: TargetKey, ...args: TranslateArgs<NamespacedValue<TranslatorMessages, Namespace, TargetKey>>): string;
+    rich<TargetKey extends NamespacedMessageKeys<TranslatorMessages, Namespace>>(key: TargetKey, ...args: TranslateArgs<NamespacedValue<TranslatorMessages, Namespace, TargetKey>, RichTagsFunction>): ReactNode;
+    markup<TargetKey extends NamespacedMessageKeys<TranslatorMessages, Namespace>>(key: TargetKey, ...args: TranslateArgs<NamespacedValue<TranslatorMessages, Namespace, TargetKey>, MarkupTagsFunction>): string;
+    raw<TargetKey extends NamespacedMessageKeys<TranslatorMessages, Namespace>>(key: TargetKey): any;
+    has<TargetKey extends NamespacedMessageKeys<TranslatorMessages, Namespace>>(key: TargetKey): boolean;
+};
+export {};

package/dist/types/core/createTranslatorImpl.d.ts

@@ -0,0 +1,17 @@
+import type AbstractIntlMessages from './AbstractIntlMessages.tsx';
+import type { InitializedIntlConfig } from './IntlConfig.tsx';
+import type { NestedKeyOf } from './MessageKeys.tsx';
+import type { Formatters, IntlCache } from './formatters.tsx';
+export type CreateTranslatorImplProps<Messages> = Omit<InitializedIntlConfig, 'messages'> & {
+    namespace: string;
+    messages: Messages;
+    formatters: Formatters;
+    cache: IntlCache;
+};
+export default function createTranslatorImpl<Messages extends AbstractIntlMessages, NestedKey extends NestedKeyOf<Messages>>({ messages, namespace, ...rest }: CreateTranslatorImplProps<Messages>, namespacePrefix: string): {
+    <TargetKey extends import("./MessageKeys.tsx").MessageKeys<import("./MessageKeys.tsx").NestedValueOf<Messages, NestedKey>, NestedKeyOf<import("./MessageKeys.tsx").NestedValueOf<Messages, NestedKey>>>>(key: TargetKey, values?: import("./TranslationValues.tsx").TranslationValues, formats?: import("./Formats.tsx").default): string;
+    rich: (key: string, values?: import("./TranslationValues.tsx").RichTranslationValues, formats?: import("./Formats.tsx").default) => import("react").ReactNode;
+    markup(key: Parameters<(key: string, values?: import("./TranslationValues.tsx").RichTranslationValues, formats?: import("./Formats.tsx").default) => import("react").ReactNode>[0], values: import("./TranslationValues.tsx").MarkupTranslationValues, formats?: Parameters<(key: string, values?: import("./TranslationValues.tsx").RichTranslationValues, formats?: import("./Formats.tsx").default) => import("react").ReactNode>[2]): string;
+    raw(key: string): any;
+    has(key: string): boolean;
+};

package/dist/types/{src/core → core}/defaults.d.ts

@@ -1,4 +1,4 @@
-import IntlError from './IntlError';
+import type IntlError from './IntlError.tsx';
 /**
  * Contains defaults that are used for all entry points into the core.
  * See also `InitializedIntlConfiguration`.

package/dist/types/{src/core → core}/formatters.d.ts

@@ -1,4 +1,4 @@
-import type IntlMessageFormat from 'intl-messageformat';
+import type { IntlMessageFormat } from 'intl-messageformat';
 export type IntlCache = {
     dateTime: Record<string, Intl.DateTimeFormat>;
     number: Record<string, Intl.NumberFormat>;

package/dist/types/core/hasLocale.d.ts

@@ -0,0 +1,10 @@
+import type { Locale } from './AppConfig.tsx';
+/**
+ * Checks if a locale exists in a list of locales.
+ *
+ * Additionally, in development, the provided locales are validated to
+ * ensure they follow the Unicode language identifier standard.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale
+ */
+export default function hasLocale<LocaleType extends Locale>(locales: ReadonlyArray<LocaleType>, candidate?: string | null): candidate is LocaleType;

package/dist/types/core/index.d.ts

@@ -0,0 +1,20 @@
+export type { default as AbstractIntlMessages } from './AbstractIntlMessages.tsx';
+export type { TranslationValues, RichTranslationValues, MarkupTranslationValues, ICUArg, ICUNumber, ICUDate, RichTagsFunction, MarkupTagsFunction } from './TranslationValues.tsx';
+export type { default as Formats } from './Formats.tsx';
+export type { default as IntlConfig } from './IntlConfig.tsx';
+export type { default as DateTimeFormatOptions } from './DateTimeFormatOptions.tsx';
+export type { default as NumberFormatOptions } from './NumberFormatOptions.tsx';
+export { default as IntlError } from './IntlError.tsx';
+export { default as IntlErrorCode } from './IntlErrorCode.tsx';
+export { default as createTranslator } from './createTranslator.tsx';
+export { default as createFormatter } from './createFormatter.tsx';
+export { default as initializeConfig } from './initializeConfig.tsx';
+export type { MessageKeys, NamespaceKeys, NestedKeyOf, NestedValueOf } from './MessageKeys.tsx';
+export { createIntlFormatters as _createIntlFormatters } from './formatters.tsx';
+export { createCache as _createCache } from './formatters.tsx';
+export type { default as AppConfig, Locale, Messages } from './AppConfig.tsx';
+export { default as hasLocale } from './hasLocale.tsx';
+export type { default as RelativeTimeFormatOptions } from './RelativeTimeFormatOptions.tsx';
+export type { default as Timezone } from './TimeZone.tsx';
+export type { default as ICUArgs } from './ICUArgs.tsx';
+export type { default as ICUTags } from './ICUTags.tsx';

package/dist/types/{src/core → core}/initializeConfig.d.ts

@@ -1,12 +1,12 @@
-import IntlConfig from './IntlConfig';
+import type IntlConfig from './IntlConfig.tsx';
 /**
  * Enhances the incoming props with defaults.
  */
 export default function initializeConfig<Props extends IntlConfig>({ getMessageFallback, messages, onError, ...rest }: Props): Omit<Props, "onError" | "getMessageFallback" | "messages"> & {
-    messages: import("./AbstractIntlMessages").default | undefined;
-    onError: (error: import("./IntlError").default) => void;
+    messages: import("./AbstractIntlMessages.tsx").default | undefined;
+    onError: (error: import("./IntlError.tsx").default) => void;
     getMessageFallback: (info: {
-        error: import("./IntlError").default;
+        error: import("./IntlError.tsx").default;
         key: string;
         namespace?: string;
     }) => string;

package/dist/types/core/types.d.ts

@@ -0,0 +1,3 @@
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/{src/core → core}/validateMessages.d.ts

@@ -1,3 +1,3 @@
-import AbstractIntlMessages from './AbstractIntlMessages';
-import IntlError from './IntlError';
+import type AbstractIntlMessages from './AbstractIntlMessages.tsx';
+import IntlError from './IntlError.tsx';
 export default function validateMessages(messages: AbstractIntlMessages, onError: (error: IntlError) => void): void;

package/dist/types/core.d.ts

@@ -0,0 +1 @@
+export * from './core/index.tsx';

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './core.tsx';
+export * from './react.tsx';

package/dist/types/{src/react → react}/IntlContext.d.ts

@@ -1,5 +1,5 @@
-import type { InitializedIntlConfig } from '../core/IntlConfig';
-import type { Formatters, IntlCache } from '../core/formatters';
+import type { InitializedIntlConfig } from '../core/IntlConfig.tsx';
+import type { Formatters, IntlCache } from '../core/formatters.tsx';
 export type IntlContextValue = InitializedIntlConfig & {
     formatters: Formatters;
     cache: IntlCache;

package/dist/types/react/IntlProvider.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from 'react';
+import type IntlConfig from '../core/IntlConfig.tsx';
+type Props = IntlConfig & {
+    children: ReactNode;
+};
+export default function IntlProvider({ children, formats, getMessageFallback, locale, messages, now, onError, timeZone }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/react/index.d.ts

@@ -0,0 +1,7 @@
+export { default as IntlProvider } from './IntlProvider.tsx';
+export { default as useTranslations } from './useTranslations.tsx';
+export { default as useLocale } from './useLocale.tsx';
+export { default as useNow } from './useNow.tsx';
+export { default as useTimeZone } from './useTimeZone.tsx';
+export { default as useMessages } from './useMessages.tsx';
+export { default as useFormatter } from './useFormatter.tsx';

package/dist/types/{src/react → react}/useFormatter.d.ts

@@ -1,2 +1,2 @@
-import createFormatter from '../core/createFormatter';
+import createFormatter from '../core/createFormatter.tsx';
 export default function useFormatter(): ReturnType<typeof createFormatter>;