use-intl 0.0.0-canary-84fe6d0 → 0.0.0-canary-58b4a57

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-CRD6euuK.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 === undefined ? prevContext?.formats : formats,
+      getMessageFallback: getMessageFallback || prevContext?.getMessageFallback,
+      messages: messages === undefined ? prevContext?.messages : 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.dev/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.dev/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.dev/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.dev/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,f as r,b as t,d as o,g as n}from"./initializeConfig-zfMDfl5R.js";export{I as IntlError,a as IntlErrorCode,c as createFormatter,i as initializeConfig}from"./initializeConfig-zfMDfl5R.js";function m({_cache:a=o(),_formatters:i=t(a),getMessageFallback:m=r,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{o 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-zfMDfl5R.js";export{createTranslator,hasLocale}from"./core.js";export{IntlProvider,useFormatter,useLocale,useMessages,useNow,useTimeZone,useTranslations}from"./react.js";

package/dist/esm/production/initializeConfig-zfMDfl5R.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 d(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,o){let u;try{u=function(e,t,r){let n;if("string"==typeof t){const r=t;if(n=e?.[r],!n){const e=new a(s.MISSING_FORMAT,void 0);throw i(e),e}}else n=t;return r&&(n={...n,...r}),n}(r,e,t)}catch{return o()}try{return n(u)}catch(e){return i(new a(s.FORMATTING_ERROR,e.message)),o()}}function I(e,t,a){return l(t,a,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,a){return l(t,a,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,a){const s=[],i=new Map;let u=0;for(const t of e){let e;"object"==typeof t?(e=String(u),i.set(e,t)):e=String(t),s.push(e),u++}return l(t,a,n?.list,(e=>{const t=r.getListFormat(o,e).formatToParts(s).map((e=>"literal"===e.type?e.value:i.get(e.value)||e.value));return i.size>0?t:t.join("")}),(()=>String(e)))},dateTimeRange:function(e,t,a,s){return l(a,s,n?.dateTime,(n=>(n=f(n),r.getDateTimeFormat(o,n).formatRange(e,t))),(()=>[I(e),I(t)].join(" – ")))}}}function h({formats:e,getMessageFallback:t,messages:r,onError:n,...o}){return{...o,formats:e||void 0,messages:r||void 0,onError:n||c,getMessageFallback:t||u}}export{a as I,s as a,g as b,d as c,m as d,E as e,u as f,c as g,h 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-zfMDfl5R.js";import{jsx as g}from"react/jsx-runtime";const d=e(void 0);function w({children:e,formats:t,getMessageFallback:n,locale:i,messages:m,now:f,onError:l,timeZone:u}){const w=r(d),v=o((()=>w?.cache||a()),[i,w?.cache]),E=o((()=>w?.formatters||s(v)),[v,w?.formatters]),h=o((()=>({...c({locale:i,formats:void 0===t?w?.formats:t,getMessageFallback:n||w?.getMessageFallback,messages:void 0===m?w?.messages:m,now:f||w?.now,onError:l||w?.onError,timeZone:u||w?.timeZone}),formatters:E,cache:v})),[v,t,E,n,i,m,f,l,w,u]);return g(d.Provider,{value:h,children:e})}function v(){const e=r(d);if(!e)throw new Error(void 0);return e}let E=!1;const h="undefined"==typeof window;function p(e){return function(e,r,t){const{cache:n,formats:a,formatters:s,getMessageFallback:c,locale:u,onError:g,timeZone:d}=v(),w=e[t],p=i(r,t);return d||E||!h||(E=!0,g(new m(f.ENVIRONMENT_FALLBACK,void 0))),o((()=>l({cache:n,formatters:s,getMessageFallback:c,messages:w,namespace:p,onError:g,formats:a,locale:u,timeZone:d})),[n,s,c,w,p,g,a,u,d])}({"!":v().messages},e?`!.${e}`:"!","!")}function Z(){return v().locale}function b(){return new Date}function F(e){const r=e?.updateInterval,{now:o}=v(),[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 v().timeZone}function k(){const e=v();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}=v();return o((()=>u({formats:e,locale:t,now:n,onError:a,timeZone:s,_formatters:r})),[e,r,n,t,a,s])}export{w as IntlProvider,I as useFormatter,Z as useLocale,k as useMessages,F as useNow,M as useTimeZone,p 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.dev/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.js';
 /**
  * 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.js';
+import type NumberFormatOptions from './NumberFormatOptions.js';
 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,17 +1,17 @@
-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 { Locale, Messages } from './AppConfig.js';
+import type Formats from './Formats.js';
+import type IntlError from './IntlError.js';
+import type TimeZone from './TimeZone.js';
+import type { DeepPartial } from './types.js';
 /**
  * Should be used for entry points that configure the library.
  */
-type IntlConfig<Messages = AbstractIntlMessages> = {
+type IntlConfig = {
     /** 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;
+    formats?: Formats | null;
     /** A time zone as defined in [the tz database](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) which will be applied when formatting dates and times. If this is absent, the user time zone will be used. You can override this by supplying an explicit time zone to `formatDateTime`. */
     timeZone?: TimeZone;
     /** This callback will be invoked when an error is encountered during
@@ -38,21 +38,17 @@ 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.dev/docs/usage/messages#rich-text-reuse-tags
-     **/
-    defaultTranslationValues?: RichTranslationValues;
+    messages?: DeepPartial<Messages> | null;
 };
+/**
 /**
  * A stricter set of the configuration that should be used internally
  * once defaults are assigned to `IntlConfiguration`.
  */
-export type InitializedIntlConfig<Messages = AbstractIntlMessages> = IntlConfig<Messages> & {
-    onError: NonNullable<IntlConfig<Messages>['onError']>;
-    getMessageFallback: NonNullable<IntlConfig<Messages>['getMessageFallback']>;
+export type InitializedIntlConfig = Omit<IntlConfig, 'formats' | 'messages' | 'onError' | 'getMessageFallback'> & {
+    formats?: NonNullable<IntlConfig['formats']>;
+    messages?: NonNullable<IntlConfig['messages']>;
+    onError: NonNullable<IntlConfig['onError']>;
+    getMessageFallback: NonNullable<IntlConfig['getMessageFallback']>;
 };
 export default IntlConfig;

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

@@ -0,0 +1,6 @@
+import type IntlErrorCode from './IntlErrorCode.js';
+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 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,6 @@
+import type { ReactNode } from 'react';
+export type TranslationValues = Record<string, string | number | Date>;
+export type RichTagsFunction = (chunks: ReactNode) => ReactNode;
+export type MarkupTagsFunction = (chunks: string) => string;
+export type RichTranslationValues = Record<string, TranslationValues[string] | RichTagsFunction>;
+export type MarkupTranslationValues = Record<string, TranslationValues[string] | 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.js';
+import type TimeZone from './TimeZone.js';
 /**
  * `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.js';
+import type Formats from './Formats.js';
+import type { InitializedIntlConfig } from './IntlConfig.js';
+import IntlError from './IntlError.js';
+import type { MessageKeys, NestedKeyOf, NestedValueOf } from './MessageKeys.js';
+import type { MarkupTranslationValues, RichTranslationValues, TranslationValues } from './TranslationValues.js';
+import { type Formatters, type IntlCache } from './formatters.js';
 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,43 @@
+import type { ReactElement } from 'react';
+import type { FormatNames, Locale } from './AppConfig.js';
+import type DateTimeFormatOptions from './DateTimeFormatOptions.js';
+import type Formats from './Formats.js';
+import IntlError from './IntlError.js';
+import type NumberFormatOptions from './NumberFormatOptions.js';
+import type RelativeTimeFormatOptions from './RelativeTimeFormatOptions.js';
+import type TimeZone from './TimeZone.js';
+import { type Formatters, type IntlCache } from './formatters.js';
+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, options?: DateTimeFormatOptions): string;
+        (value: Date | number, format?: FormatNames["dateTime"], options?: DateTimeFormatOptions): string;
+    };
+    number: {
+        (value: number | bigint, options?: NumberFormatOptions): string;
+        (value: number | bigint, format?: FormatNames["number"], options?: NumberFormatOptions): string;
+    };
+    relativeTime: {
+        (date: number | Date, now?: RelativeTimeFormatOptions["now"]): string;
+        (date: number | Date, options?: RelativeTimeFormatOptions): string;
+    };
+    list: {
+        <Value extends string | ReactElement<unknown, string | import("react").JSXElementConstructor<any>>>(value: Iterable<Value>, options?: Intl.ListFormatOptions): Value extends string ? string : Iterable<ReactElement>;
+        <Value extends string | ReactElement<unknown, string | import("react").JSXElementConstructor<any>>>(value: Iterable<Value>, format?: FormatNames["list"], options?: Intl.ListFormatOptions): Value extends string ? string : Iterable<ReactElement>;
+    };
+    dateTimeRange: {
+        (start: Date | number, end: Date | number, options?: DateTimeFormatOptions): string;
+        (start: Date | number, end: Date | number, format?: FormatNames["dateTime"], options?: DateTimeFormatOptions): string;
+    };
+};
+export {};

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

@@ -0,0 +1,55 @@
+import type { ReactNode } from 'react';
+import type Formats from './Formats.js';
+import type ICUArgs from './ICUArgs.js';
+import type ICUTags from './ICUTags.js';
+import type IntlConfig from './IntlConfig.js';
+import type { MessageKeys, NamespaceKeys, NestedKeyOf, NestedValueOf } from './MessageKeys.js';
+import type { MarkupTagsFunction, RichTagsFunction, TranslationValues } from './TranslationValues.js';
+import { type Formatters, type IntlCache } from './formatters.js';
+import type { Prettify } from './types.js';
+type ICUArgsWithTags<MessageString extends string, TagsFn extends RichTagsFunction | MarkupTagsFunction = never> = ICUArgs<MessageString, {
+    ICUArgument: string;
+    ICUNumberArgument: number;
+    ICUDateArgument: Date;
+}> & ([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, TranslationValues[string] | 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 IntlMessages = Record<string, any>;
+type NamespacedMessageKeys<TranslatorMessages extends IntlMessages, 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 IntlMessages, 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 IntlMessages, const Namespace extends NamespaceKeys<TranslatorMessages, NestedKeyOf<TranslatorMessages>> = never>({ _cache, _formatters, getMessageFallback, messages, namespace, onError, ...rest }: Omit<IntlConfig, '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.js';
+import type { InitializedIntlConfig } from './IntlConfig.js';
+import type { NestedKeyOf } from './MessageKeys.js';
+import type { Formatters, IntlCache } from './formatters.js';
+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.js").MessageKeys<import("./MessageKeys.js").NestedValueOf<Messages, NestedKey>, NestedKeyOf<import("./MessageKeys.js").NestedValueOf<Messages, NestedKey>>>>(key: TargetKey, values?: import("./TranslationValues.js").TranslationValues, formats?: import("./Formats.js").default): string;
+    rich: (key: string, values?: import("./TranslationValues.js").RichTranslationValues, formats?: import("./Formats.js").default) => import("react").ReactNode;
+    markup(key: Parameters<(key: string, values?: import("./TranslationValues.js").RichTranslationValues, formats?: import("./Formats.js").default) => import("react").ReactNode>[0], values: import("./TranslationValues.js").MarkupTranslationValues, formats?: Parameters<(key: string, values?: import("./TranslationValues.js").RichTranslationValues, formats?: import("./Formats.js").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.js';
 /**
  * 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,7 @@
+import type { Locale } from './AppConfig.js';
+/**
+ * Checks if a locale exists in a list of locales.
+ *
+ * @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: unknown): candidate is LocaleType;

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

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

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

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

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

@@ -0,0 +1,6 @@
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type DeepPartial<Type> = {
+    [Key in keyof Type]?: Type[Key] extends object ? DeepPartial<Type[Key]> : Type[Key];
+};

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.js';
+import IntlError from './IntlError.js';
 export default function validateMessages(messages: AbstractIntlMessages, onError: (error: IntlError) => void): void;

package/dist/types/core.d.ts

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

package/dist/types/index.d.ts

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