@common.js/use-intl 4.13.1

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

@@ -0,0 +1,59 @@
+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 | bigint;
+    ICUDateArgument: Date;
+}> & ([TagsFn] extends [never] ? {} : ICUTags<MessageString, TagsFn>);
+type OnlyOptional<T> = Partial<T> extends T ? true : false;
+export 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}`>;
+/**
+ * @private Not intended for direct use.
+ */
+export type Translator<TranslatorMessages extends IntlMessages = IntlMessages, Namespace extends NamespaceKeys<TranslatorMessages, NestedKeyOf<TranslatorMessages>> = never> = {
+    <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;
+};
+/**
+ * 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;
+}): Translator<TranslatorMessages, Namespace>;
+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, _fallback?: never): string;
+    rich: (key: string, values?: import("./TranslationValues.js").RichTranslationValues, formats?: import("./Formats.js").default, _fallback?: never) => import("react").ReactNode;
+    markup(key: Parameters<(key: string, values?: import("./TranslationValues.js").RichTranslationValues, formats?: import("./Formats.js").default, _fallback?: never) => import("react").ReactNode>[0], values: import("./TranslationValues.js").MarkupTranslationValues, formats?: Parameters<(key: string, values?: import("./TranslationValues.js").RichTranslationValues, formats?: import("./Formats.js").default, _fallback?: never) => import("react").ReactNode>[2], _fallback?: never): string;
+    raw(key: string): any;
+    has(key: string): boolean;
+};

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

@@ -0,0 +1,11 @@
+import type IntlError from './IntlError.js';
+/**
+ * Contains defaults that are used for all entry points into the core.
+ * See also `InitializedIntlConfiguration`.
+ */
+export declare function defaultGetMessageFallback(props: {
+    error: IntlError;
+    key: string;
+    namespace?: string;
+}): string;
+export declare function defaultOnError(error: IntlError): void;

package/dist/types/core/format-message/compile-format.d.ts

@@ -0,0 +1,12 @@
+import type { FormatMessage } from './types.js';
+/**
+ * Compiles and formats an ICU message at runtime using intl-messageformat.
+ * This is the default implementation used when messages are not precompiled.
+ */
+declare function formatMessage(
+/** The raw ICU message string (or precompiled message, though this implementation ignores precompilation) */
+...[key, message, values, options]: Parameters<FormatMessage<string>>): ReturnType<FormatMessage<string>>;
+declare namespace formatMessage {
+    var raw: boolean;
+}
+export default formatMessage;

package/dist/types/core/format-message/format-only.d.ts

@@ -0,0 +1,13 @@
+import { type CompiledMessage } from 'icu-minify/format';
+import type { FormatMessage } from './types.js';
+/**
+ * Formats a precompiled ICU message using icu-minify/format.
+ * This implementation requires messages to be precompiled at build time.
+ */
+declare function formatMessage(
+/** The precompiled ICU message (CompiledMessage from icu-minify) */
+...[, message, values, options]: Parameters<FormatMessage<CompiledMessage>>): ReturnType<FormatMessage<CompiledMessage>>;
+declare namespace formatMessage {
+    var raw: boolean;
+}
+export default formatMessage;

package/dist/types/core/format-message/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This module provides the default implementation, but can
+ * be aliased to use the format-only implementation.
+ */
+export { default } from './compile-format.js';

package/dist/types/core/format-message/types.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from 'react';
+import type Formats from '../Formats.js';
+import type TimeZone from '../TimeZone.js';
+import type { RichTranslationValues } from '../TranslationValues.js';
+import type { Formatters, IntlCache } from '../formatters.js';
+type FormatMessageOptions = {
+    cache: IntlCache;
+    formatters: Formatters;
+    globalFormats?: Formats;
+    formats?: Formats;
+    locale: string;
+    timeZone?: TimeZone;
+};
+export type FormatMessage<Message> = (key: string, message: Message, values: RichTranslationValues | undefined, options: FormatMessageOptions) => ReactNode;
+export {};

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

@@ -0,0 +1,25 @@
+import type { IntlMessageFormat } from 'intl-messageformat';
+export type IntlCache = {
+    dateTime: Record<string, Intl.DateTimeFormat>;
+    number: Record<string, Intl.NumberFormat>;
+    message: Record<string, IntlMessageFormat>;
+    relativeTime: Record<string, Intl.RelativeTimeFormat>;
+    pluralRules: Record<string, Intl.PluralRules>;
+    list: Record<string, Intl.ListFormat>;
+    displayNames: Record<string, Intl.DisplayNames>;
+};
+export declare function createCache(): IntlCache;
+export declare function memoFn<Fn extends (...args: Array<any>) => any>(fn: Fn, cache: Record<string, ReturnType<Fn> | undefined>): Fn;
+export type IntlFormatters = {
+    getDateTimeFormat(...args: ConstructorParameters<typeof Intl.DateTimeFormat>): Intl.DateTimeFormat;
+    getNumberFormat(...args: ConstructorParameters<typeof Intl.NumberFormat>): Intl.NumberFormat;
+    getPluralRules(...args: ConstructorParameters<typeof Intl.PluralRules>): Intl.PluralRules;
+    getRelativeTimeFormat(...args: ConstructorParameters<typeof Intl.RelativeTimeFormat>): Intl.RelativeTimeFormat;
+    getListFormat(...args: ConstructorParameters<typeof Intl.ListFormat>): Intl.ListFormat;
+    getDisplayNames(...args: ConstructorParameters<typeof Intl.DisplayNames>): Intl.DisplayNames;
+};
+export declare function createIntlFormatters(cache: IntlCache): IntlFormatters;
+export type MessageFormatter = (...args: ConstructorParameters<typeof IntlMessageFormat>) => IntlMessageFormat;
+export type Formatters = IntlFormatters & {
+    getMessageFormat?: MessageFormatter;
+};

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,22 @@
+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';
+/** @private -- Only for type portability */
+export type { Translator as _Translator } from './createTranslator.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/joinPath.d.ts

@@ -0,0 +1 @@
+export default function joinPath(...parts: Array<string | undefined>): string;

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

@@ -0,0 +1,5 @@
+/**
+ * For the strictly typed messages to work we have to wrap the namespace into
+ * a mandatory prefix. See https://stackoverflow.com/a/71529575/343045
+ */
+export default function resolveNamespace(namespace: string, namespacePrefix: string): string | undefined;

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/core/validateMessages.d.ts

@@ -0,0 +1,3 @@
+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';

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

@@ -0,0 +1,8 @@
+import type { InitializedIntlConfig } from '../core/IntlConfig.js';
+import type { Formatters, IntlCache } from '../core/formatters.js';
+export type IntlContextValue = InitializedIntlConfig & {
+    formatters: Formatters;
+    cache: IntlCache;
+};
+declare const IntlContext: import("react").Context<IntlContextValue | undefined>;
+export default IntlContext;

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

@@ -0,0 +1,7 @@
+import { type ReactNode } from 'react';
+import type IntlConfig from '../core/IntlConfig.js';
+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,9 @@
+export { default as IntlProvider } from './IntlProvider.js';
+export { default as useTranslations } from './useTranslations.js';
+export { default as useLocale } from './useLocale.js';
+export { default as useNow } from './useNow.js';
+export { default as useTimeZone } from './useTimeZone.js';
+export { default as useMessages } from './useMessages.js';
+export { default as useFormatter } from './useFormatter.js';
+/** @private -- Only for usage in `next-intl` currently */
+export { default as _useExtracted } from './useExtracted.js';

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

@@ -0,0 +1,42 @@
+import type { ReactNode } from 'react';
+import type { MarkupTagsFunction, RichTagsFunction } from '../core/TranslationValues.js';
+import type { TranslateArgs } from '../core/createTranslator.js';
+type TranslateArgsObject<Value extends string, TagsFn extends RichTagsFunction | MarkupTagsFunction = never> = TranslateArgs<Value, TagsFn> extends readonly [any?, any?] ? undefined extends TranslateArgs<Value, TagsFn>[0] ? {
+    values?: TranslateArgs<Value, TagsFn>[0];
+    formats?: TranslateArgs<Value, TagsFn>[1];
+} : {
+    values: TranslateArgs<Value, TagsFn>[0];
+    formats?: TranslateArgs<Value, TagsFn>[1];
+} : never;
+export default function useExtracted(namespace?: string): {
+    <Message extends string>(message: Message, ...[values, formats]: TranslateArgs<Message>): string;
+    <Message extends string>(params: {
+        id?: string;
+        /** Inline ICU message in the source locale. */
+        message: Message;
+        /** Description for translators and tooling. */
+        description?: string;
+    } & TranslateArgsObject<Message>): string;
+    rich: {
+        <Message extends string>(message: Message, ...[values, formats]: TranslateArgs<Message, RichTagsFunction>): ReactNode;
+        <Message extends string>(params: {
+            id?: string;
+            /** Inline ICU message in the source locale. */
+            message: Message;
+            /** Description for translators and tooling. */
+            description?: string;
+        } & TranslateArgsObject<Message, RichTagsFunction>): ReactNode;
+    };
+    markup: {
+        <Message extends string>(message: Message, ...[values, formats]: TranslateArgs<Message, MarkupTagsFunction>): string;
+        <Message extends string>(params: {
+            id?: string;
+            /** Inline ICU message in the source locale. */
+            message: Message;
+            /** Description for translators and tooling. */
+            description?: string;
+        } & TranslateArgsObject<Message, MarkupTagsFunction>): string;
+    };
+    has<Message extends string>(message: Message): boolean;
+};
+export {};

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

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

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

@@ -0,0 +1,2 @@
+import { type IntlContextValue } from './IntlContext.js';
+export default function useIntlContext(): IntlContextValue;

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

@@ -0,0 +1,2 @@
+import type { Locale } from '../core.js';
+export default function useLocale(): Locale;

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

@@ -0,0 +1,2 @@
+import type { Messages } from '../core/AppConfig.js';
+export default function useMessages(): Messages;

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

@@ -0,0 +1,8 @@
+type Options = {
+    updateInterval?: number;
+};
+/**
+ * @see https://next-intl.dev/docs/usage/dates-times#relative-times-usenow
+ */
+export default function useNow(options?: Options): Date;
+export {};

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

@@ -0,0 +1 @@
+export default function useTimeZone(): import("../core.js").Timezone | undefined;

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

@@ -0,0 +1,12 @@
+import type { Messages } from '../core/AppConfig.js';
+import type { NamespaceKeys, NestedKeyOf } from '../core/MessageKeys.js';
+import type createTranslator from '../core/createTranslator.js';
+/**
+ * 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 useTranslations<NestedKey extends NamespaceKeys<Messages, NestedKeyOf<Messages>> = never>(namespace?: NestedKey): ReturnType<typeof createTranslator<Messages, NestedKey>>;

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

@@ -0,0 +1,9 @@
+import type AbstractIntlMessages from '../core/AbstractIntlMessages.js';
+import type { NestedKeyOf } from '../core/MessageKeys.js';
+export default function useTranslationsImpl<Messages extends AbstractIntlMessages, NestedKey extends NestedKeyOf<Messages>>(allMessagesPrefixed: Messages, namespacePrefixed: NestedKey, namespacePrefix: string): {
+    <TargetKey extends unknown>(key: TargetKey, values?: import("../core.js").TranslationValues, formats?: import("../core.js").Formats, _fallback?: never): string;
+    rich: (key: string, values?: import("../core.js").RichTranslationValues, formats?: import("../core.js").Formats, _fallback?: never) => import("react").ReactNode;
+    markup(key: Parameters<(key: string, values?: import("../core.js").RichTranslationValues, formats?: import("../core.js").Formats, _fallback?: never) => import("react").ReactNode>[0], values: import("../core.js").MarkupTranslationValues, formats?: Parameters<(key: string, values?: import("../core.js").RichTranslationValues, formats?: import("../core.js").Formats, _fallback?: never) => import("react").ReactNode>[2], _fallback?: never): string;
+    raw(key: string): any;
+    has(key: string): boolean;
+};

package/dist/types/react.d.ts

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

package/format-message/format-only.d.ts

@@ -0,0 +1,2 @@
+// Needed for projects with `moduleResolution: 'node'`
+export * from '../dist/types/core/format-message/format-only.d.ts';

package/format-message.d.ts

@@ -0,0 +1,2 @@
+// Needed for projects with `moduleResolution: 'node'`
+export * from './dist/types/core/format-message/index.d.ts';

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@common.js/use-intl",
+  "version": "4.13.1",
+  "sideEffects": false,
+  "funding": [
+    {
+      "type": "individual",
+      "url": "https://github.com/sponsors/amannn"
+    }
+  ],
+  "description": "use-intl package exported as CommonJS modules",
+  "license": "MIT",
+  "homepage": "https://github.com/etienne-martin/common.js#readme",
+  "repository": "etienne-martin/common.js",
+  "scripts": {
+    "build": "rm -rf dist && rollup -c",
+    "test": "TZ=Europe/Berlin vitest",
+    "lint": "pnpm run lint:source && pnpm run lint:package",
+    "lint:source": "eslint src test && tsc --noEmit && pnpm run lint:prettier",
+    "lint:package": "publint && attw --pack --ignore-rules=cjs-resolves-to-esm",
+    "lint:prettier": "prettier src --check",
+    "size": "size-limit"
+  },
+  "type": "commonjs",
+  "main": "./dist/esm/production/index.js",
+  "typings": "./dist/types/index.d.ts",
+  "files": [
+    "dist",
+    "core.d.ts",
+    "react.d.ts",
+    "format-message.d.ts",
+    "format-message"
+  ],
+  "dependencies": {
+    "@common.js/formatjs__fast-memoize": "^3.1.0",
+    "@common.js/schummar__icu-type-parser": "1.21.5",
+    "@common.js/icu-minify": "^4.13.1",
+    "@common.js/intl-messageformat": "^11.1.0"
+  },
+  "peerDependencies": {
+    "react": "^17.0.0 || ^18.0.0 || >=19.0.0-rc <19.0.0 || ^19.0.0"
+  },
+  "gitHead": "976ca1f83a6e06b5646865b87c4fb461cbf84374",
+  "types": "./dist/types/index.d.ts"
+}

package/react.d.ts

@@ -0,0 +1,2 @@
+// Needed for projects with `moduleResolution: 'node'`
+export * from './dist/types/react.d.ts';