@intlayer/next-intl 8.12.5-canary.0

package/dist/esm/routing.mjs

@@ -0,0 +1,28 @@
+import { internationalization, routing } from "@intlayer/config/built";
+
+//#region src/routing.ts
+/**
+* Drop-in replacement for next-intl's `defineRouting()`.
+*
+* Merges the provided config with Intlayer's own routing / internationalization
+* configuration so you don't have to repeat locale lists. All fields are
+* optional — omitted values are read from the Intlayer config at runtime.
+*
+* @example
+* ```ts
+* export default defineRouting({
+*   locales: ['en', 'fr'],
+*   defaultLocale: 'en',
+* });
+* ```
+*/
+const defineRouting = (config) => ({
+	locales: config?.locales ?? internationalization?.locales ?? [],
+	defaultLocale: config?.defaultLocale ?? internationalization?.defaultLocale,
+	localePrefix: config?.localePrefix ?? (routing?.prefixDefault ? "always" : "as-needed"),
+	...config
+});
+
+//#endregion
+export { defineRouting };
+//# sourceMappingURL=routing.mjs.map

package/dist/esm/routing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.mjs","names":[],"sources":["../../src/routing.ts"],"sourcesContent":["import { internationalization, routing } from '@intlayer/config/built';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\n\nexport type Routing = {\n  locales: LocalesValues[];\n  defaultLocale: LocalesValues;\n  localePrefix?: 'always' | 'as-needed' | 'never';\n  pathnames?: Record<string, string | Record<string, string>>;\n};\n\n/**\n * Drop-in replacement for next-intl's `defineRouting()`.\n *\n * Merges the provided config with Intlayer's own routing / internationalization\n * configuration so you don't have to repeat locale lists. All fields are\n * optional — omitted values are read from the Intlayer config at runtime.\n *\n * @example\n * ```ts\n * export default defineRouting({\n *   locales: ['en', 'fr'],\n *   defaultLocale: 'en',\n * });\n * ```\n */\nexport const defineRouting: (config?: Partial<Routing>) => Routing = (\n  config?: Partial<Routing>\n): Routing => ({\n  locales:\n    config?.locales ??\n    ((internationalization?.locales ?? []) as LocalesValues[]),\n  defaultLocale:\n    config?.defaultLocale ??\n    (internationalization?.defaultLocale as LocalesValues),\n  localePrefix:\n    config?.localePrefix ?? (routing?.prefixDefault ? 'always' : 'as-needed'),\n  ...config,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAyBA,MAAa,iBACX,YACa;CACb,SACE,QAAQ,WACN,sBAAsB,WAAW,EAAE;CACvC,eACE,QAAQ,iBACP,sBAAsB;CACzB,cACE,QAAQ,iBAAiB,SAAS,gBAAgB,WAAW;CAC/D,GAAG;CACJ"}

package/dist/esm/server/getLocale.mjs

@@ -0,0 +1,11 @@
+import { getLocale as getLocale$1 } from "next-intlayer/server";
+
+//#region src/server/getLocale.ts
+/**
+* Drop-in for next-intl's `getLocale()` server function.
+*/
+const getLocale = async () => await getLocale$1();
+
+//#endregion
+export { getLocale };
+//# sourceMappingURL=getLocale.mjs.map

package/dist/esm/server/getLocale.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getLocale.mjs","names":["getLocaleIntlayer"],"sources":["../../../src/server/getLocale.ts"],"sourcesContent":["import type { getLocale as _getLocale } from 'next-intl/server';\nimport { getLocale as getLocaleIntlayer } from 'next-intlayer/server';\n\n/**\n * Drop-in for next-intl's `getLocale()` server function.\n */\nexport const getLocale: typeof _getLocale = async (): Promise<string> =>\n  (await getLocaleIntlayer()) as string;\n"],"mappings":";;;;;;AAMA,MAAa,YAA+B,YACzC,MAAMA,aAAmB"}

package/dist/esm/server/getMessages.mjs

@@ -0,0 +1,28 @@
+import { log } from "@intlayer/config/built";
+import { CYAN } from "@intlayer/config/colors";
+import { colorize, getAppLogger } from "@intlayer/config/logger";
+
+//#region src/server/getMessages.ts
+/**
+* Drop-in replacement for next-intl's `getMessages()` server function.
+*
+* Returns all compiled dictionary content for the current locale as a flat
+* record keyed by dictionary name. Useful when you need to pass messages
+* to a `NextIntlClientProvider`.
+*
+* @example
+* ```ts
+* const messages = await getMessages();
+* ```
+*
+* @deprecated getMessages has no use case with intlayer.
+* Messages are loaded automatically under the hood
+*/
+const getMessages = async () => {
+	getAppLogger({ log })(`${colorize("getMessages", CYAN)} has no use case with intlayer. Messages are loaded automatically under the hood for bundle optimization reason`);
+	return {};
+};
+
+//#endregion
+export { getMessages };
+//# sourceMappingURL=getMessages.mjs.map

package/dist/esm/server/getMessages.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMessages.mjs","names":[],"sources":["../../../src/server/getMessages.ts"],"sourcesContent":["import { log } from '@intlayer/config/built';\nimport { CYAN } from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport type { getMessages as _getMessages } from 'next-intl/server';\n\n/**\n * Drop-in replacement for next-intl's `getMessages()` server function.\n *\n * Returns all compiled dictionary content for the current locale as a flat\n * record keyed by dictionary name. Useful when you need to pass messages\n * to a `NextIntlClientProvider`.\n *\n * @example\n * ```ts\n * const messages = await getMessages();\n * ```\n *\n * @deprecated getMessages has no use case with intlayer.\n * Messages are loaded automatically under the hood\n */\nexport const getMessages: typeof _getMessages = async () => {\n  if (process.env.NODE_ENV === 'development') {\n    const appLogger = getAppLogger({ log });\n    appLogger(\n      `${colorize('getMessages', CYAN)} has no use case with intlayer. Messages are loaded automatically under the hood for bundle optimization reason`\n    );\n  }\n\n  return {};\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,cAAmC,YAAY;AAGxD,CADkB,aAAa,EAAE,KAAK,CAC7B,CACP,GAAG,SAAS,eAAe,KAAK,CAAC,iHAClC;AAGH,QAAO,EAAE"}

package/dist/esm/server/getTranslations.mjs

@@ -0,0 +1,44 @@
+import { getLocale } from "./getLocale.mjs";
+import { createTranslator } from "../createTranslator.mjs";
+
+//#region src/server/getTranslations.ts
+/**
+* Drop-in for next-intl's server `getTranslations()`.
+*
+* Messages support ICU MessageFormat syntax: simple arguments (`{name}`),
+* plural (`{count, plural, one {…} other {…}}`, `#`), select, and formatted
+* arguments (`{value, number}`). Rich text is available through `t.rich()`
+* and `t.markup()`.
+*
+* Also accepts an options object `{ namespace, locale }` to match next-intl's
+* full server API surface.
+*
+* @example
+* ```ts
+* // Bare namespace — fully typed dot-paths
+* const t = await getTranslations('about');
+* return <h1>{t('counter.label')}</h1>;
+*
+* // ICU plural
+* t('items', { count: 3 });
+*
+* // Options object with locale override
+* const t = await getTranslations({ namespace: 'about', locale: 'fr' });
+*
+* // Rich text
+* t.rich('terms', { link: (chunks) => <a href="/terms">{chunks}</a> });
+* ```
+*/
+const getTranslations = (async (namespaceOrOptions) => {
+	let namespace;
+	let localeOverride;
+	if (typeof namespaceOrOptions === "object" && namespaceOrOptions !== null) {
+		namespace = namespaceOrOptions.namespace;
+		localeOverride = namespaceOrOptions.locale;
+	} else namespace = namespaceOrOptions;
+	return createTranslator(localeOverride ?? await getLocale(), namespace);
+});
+
+//#endregion
+export { getTranslations };
+//# sourceMappingURL=getTranslations.mjs.map

package/dist/esm/server/getTranslations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getTranslations.mjs","names":[],"sources":["../../../src/server/getTranslations.ts"],"sourcesContent":["import type { ValidDotPathsFor } from '@intlayer/core/transpiler';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport type { ReactNode } from 'react';\nimport {\n  createTranslator,\n  type MarkupChunkRenderer,\n  type RichChunkRenderer,\n} from '../createTranslator';\nimport { getLocale } from './getLocale';\n\n/**\n * Options accepted by the options-object overload of {@link getTranslations}.\n */\ntype GetTranslationsOptions<N extends DictionaryKeys> = {\n  /** The dictionary namespace to scope translations to. */\n  namespace?: N;\n  /** Override the locale instead of reading it from the current request. */\n  locale?: LocalesValues;\n};\n\n/**\n * The translation function returned by {@link getTranslations}.\n *\n * Beyond the plain call signature, the function exposes:\n * - `has(key)` — returns `true` when the key exists in the namespace.\n * - `raw(key)` — returns the unprocessed message value.\n * - `rich(key, values)` — resolves `<tag>chunks</tag>` markup to React nodes.\n * - `markup(key, values)` — resolves `<tag>chunks</tag>` markup to a string.\n */\ntype TranslateFunction<N extends DictionaryKeys> = {\n  /** Translate a key to a string, with optional ICU interpolation params. */\n  <P extends ValidDotPathsFor<N>>(\n    key: P,\n    params?: Record<string, unknown>\n  ): string;\n  /** Returns `true` if the given key exists in the namespace. */\n  has<P extends ValidDotPathsFor<N>>(key: P): boolean;\n  /** Returns the raw unprocessed message for the given key. */\n  raw<P extends ValidDotPathsFor<N>>(key: P): unknown;\n  /** Resolves rich-text markup, mapping tags through React renderers. */\n  rich<P extends ValidDotPathsFor<N>>(\n    key: P,\n    values?: Record<string, RichChunkRenderer | ReactNode>\n  ): ReactNode;\n  /** Resolves rich-text markup, mapping tags through string renderers. */\n  markup<P extends ValidDotPathsFor<N>>(\n    key: P,\n    values?: Record<string, MarkupChunkRenderer | string | number>\n  ): string;\n};\n\n/** Loosely-typed function returned for nested `'dict.scope'` namespaces. */\ntype LooseTranslateFunction = {\n  (key: string, params?: Record<string, unknown>): string;\n  has(key: string): boolean;\n  raw(key: string): unknown;\n  rich(\n    key: string,\n    values?: Record<string, RichChunkRenderer | ReactNode>\n  ): ReactNode;\n  markup(\n    key: string,\n    values?: Record<string, MarkupChunkRenderer | string | number>\n  ): string;\n};\n\n/**\n * Overload set for {@link getTranslations}:\n *\n * 1. A bare dictionary key → fully-typed `t()` (autocompleted dot-paths).\n * 2. An options object `{ namespace?, locale? }` → typed when namespace is\n *    a known `DictionaryKeys` value.\n * 3. A nested namespace `'dictionary.sub.scope'` → `t()` accepts relative\n *    `string` paths, matching next-intl's scoped-namespace behaviour.\n * 4. No namespace → root scope; the first segment of each key designates\n *    the dictionary (`t('about.title')`).\n */\ntype GetTranslations = {\n  <N extends DictionaryKeys>(namespace: N): Promise<TranslateFunction<N>>;\n  <N extends DictionaryKeys>(\n    options: GetTranslationsOptions<N>\n  ): Promise<TranslateFunction<N>>;\n  (namespace: `${string}.${string}`): Promise<LooseTranslateFunction>;\n  (): Promise<LooseTranslateFunction>;\n};\n\n/**\n * Drop-in for next-intl's server `getTranslations()`.\n *\n * Messages support ICU MessageFormat syntax: simple arguments (`{name}`),\n * plural (`{count, plural, one {…} other {…}}`, `#`), select, and formatted\n * arguments (`{value, number}`). Rich text is available through `t.rich()`\n * and `t.markup()`.\n *\n * Also accepts an options object `{ namespace, locale }` to match next-intl's\n * full server API surface.\n *\n * @example\n * ```ts\n * // Bare namespace — fully typed dot-paths\n * const t = await getTranslations('about');\n * return <h1>{t('counter.label')}</h1>;\n *\n * // ICU plural\n * t('items', { count: 3 });\n *\n * // Options object with locale override\n * const t = await getTranslations({ namespace: 'about', locale: 'fr' });\n *\n * // Rich text\n * t.rich('terms', { link: (chunks) => <a href=\"/terms\">{chunks}</a> });\n * ```\n */\nexport const getTranslations: GetTranslations = (async (\n  namespaceOrOptions?: string | GetTranslationsOptions<DictionaryKeys>\n) => {\n  let namespace: string | undefined;\n  let localeOverride: LocalesValues | undefined;\n\n  if (typeof namespaceOrOptions === 'object' && namespaceOrOptions !== null) {\n    namespace = namespaceOrOptions.namespace;\n    localeOverride = namespaceOrOptions.locale;\n  } else {\n    namespace = namespaceOrOptions as string | undefined;\n  }\n\n  const locale = localeOverride ?? (await getLocale());\n\n  return createTranslator(locale as LocalesValues, namespace);\n}) as GetTranslations;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoHA,MAAa,mBAAoC,OAC/C,uBACG;CACH,IAAI;CACJ,IAAI;AAEJ,KAAI,OAAO,uBAAuB,YAAY,uBAAuB,MAAM;AACzE,cAAY,mBAAmB;AAC/B,mBAAiB,mBAAmB;OAEpC,aAAY;AAKd,QAAO,iBAFQ,kBAAmB,MAAM,WAAW,EAEF,UAAU"}

package/dist/esm/server/helpers.mjs

@@ -0,0 +1,25 @@
+import { createFormatter } from "../createFormatter.mjs";
+import { getLocale } from "./getLocale.mjs";
+
+//#region src/server/helpers.ts
+/**
+* Drop-in for next-intl's server `getFormatter()`.
+* Returns locale-aware formatters backed by the native `Intl.*` APIs.
+*/
+const getFormatter = (async (options) => {
+	return createFormatter(options?.locale ?? await getLocale());
+});
+/**
+* Drop-in for next-intl's server `getNow()`.
+* Returns the current `Date`.
+*/
+const getNow = (async () => /* @__PURE__ */ new Date());
+/**
+* Drop-in for next-intl's server `getTimeZone()`.
+* Returns the system time zone resolved from `Intl.DateTimeFormat`.
+*/
+const getTimeZone = (async () => Intl.DateTimeFormat().resolvedOptions().timeZone);
+
+//#endregion
+export { getFormatter, getNow, getTimeZone };
+//# sourceMappingURL=helpers.mjs.map

package/dist/esm/server/helpers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.mjs","names":[],"sources":["../../../src/server/helpers.ts"],"sourcesContent":["import type {\n  getFormatter as _getFormatter,\n  getNow as _getNow,\n  getTimeZone as _getTimeZone,\n} from 'next-intl/server';\nimport { createFormatter } from '../createFormatter';\nimport { getLocale } from './getLocale';\n\n/**\n * Drop-in for next-intl's server `getFormatter()`.\n * Returns locale-aware formatters backed by the native `Intl.*` APIs.\n */\nexport const getFormatter: typeof _getFormatter = (async (options?: {\n  locale?: string;\n}) => {\n  const locale = options?.locale ?? (await getLocale());\n  return createFormatter(locale as string);\n}) as typeof _getFormatter;\n\n/**\n * Drop-in for next-intl's server `getNow()`.\n * Returns the current `Date`.\n */\nexport const getNow: typeof _getNow = (async () =>\n  new Date()) as typeof _getNow;\n\n/**\n * Drop-in for next-intl's server `getTimeZone()`.\n * Returns the system time zone resolved from `Intl.DateTimeFormat`.\n */\nexport const getTimeZone: typeof _getTimeZone = (async () =>\n  Intl.DateTimeFormat().resolvedOptions().timeZone) as typeof _getTimeZone;\n"],"mappings":";;;;;;;;AAYA,MAAa,gBAAsC,OAAO,YAEpD;AAEJ,QAAO,gBADQ,SAAS,UAAW,MAAM,WAAW,CACZ;;;;;;AAO1C,MAAa,UAA0B,4BACrC,IAAI,MAAM;;;;;AAMZ,MAAa,eAAoC,YAC/C,KAAK,gBAAgB,CAAC,iBAAiB,CAAC"}

package/dist/esm/server/index.mjs

@@ -0,0 +1,9 @@
+import { getLocale } from "./getLocale.mjs";
+import { getDictionary } from "../getDictionary.mjs";
+import { getDictionaryDynamic } from "../getDictionaryDynamic.mjs";
+import { getFormatter, getNow, getTimeZone } from "./helpers.mjs";
+import { setLocale } from "./setLocale.mjs";
+import { getTranslations } from "./getTranslations.mjs";
+import { getMessages } from "./getMessages.mjs";
+
+export { getDictionary, getDictionaryDynamic, getFormatter, getLocale, getMessages, getNow, getTimeZone, getTranslations, setLocale };

package/dist/esm/server/setLocale.mjs

@@ -0,0 +1,36 @@
+import { setLocaleInStorageServer } from "@intlayer/core/utils";
+import { cookies } from "next/headers.js";
+
+//#region src/server/setLocale.ts
+/**
+* Drop-in replacement for next-intl's `setLocale()` server action.
+*
+* Writes the locale to whichever cookie(s) the active `routing.storage`
+* configuration specifies. When `createNextIntlPlugin` is used (the default),
+* this is `NEXT_LOCALE`; when the user has configured a custom storage in
+* `intlayer.config.ts`, that name is used instead.
+*
+* Must be called inside a Server Action.
+*
+* @example
+* ```ts
+* 'use server';
+* await setLocale('fr');
+* ```
+*/
+const setLocale = async (locale) => {
+	const cookieStore = await cookies();
+	setLocaleInStorageServer(locale, { setCookieStore: (name, value, attributes) => {
+		cookieStore.set(name, value, {
+			...attributes ?? {},
+			path: attributes?.path ?? "/",
+			sameSite: attributes?.sameSite ?? "lax",
+			httpOnly: attributes?.httpOnly ?? false,
+			secure: attributes?.secure ?? false
+		});
+	} });
+};
+
+//#endregion
+export { setLocale };
+//# sourceMappingURL=setLocale.mjs.map

package/dist/esm/server/setLocale.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"setLocale.mjs","names":[],"sources":["../../../src/server/setLocale.ts"],"sourcesContent":["import { setLocaleInStorageServer } from '@intlayer/core/utils';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { cookies } from 'next/headers.js';\n\n/**\n * Drop-in replacement for next-intl's `setLocale()` server action.\n *\n * Writes the locale to whichever cookie(s) the active `routing.storage`\n * configuration specifies. When `createNextIntlPlugin` is used (the default),\n * this is `NEXT_LOCALE`; when the user has configured a custom storage in\n * `intlayer.config.ts`, that name is used instead.\n *\n * Must be called inside a Server Action.\n *\n * @example\n * ```ts\n * 'use server';\n * await setLocale('fr');\n * ```\n */\nexport const setLocale = async (locale: string): Promise<void> => {\n  const cookieStore = await cookies();\n\n  setLocaleInStorageServer(locale as LocalesValues, {\n    setCookieStore: (name, value, attributes) => {\n      cookieStore.set(name, value, {\n        ...(attributes ?? {}),\n        path: attributes?.path ?? '/',\n        sameSite: (attributes?.sameSite as 'lax') ?? 'lax',\n        httpOnly: attributes?.httpOnly ?? false,\n        secure: attributes?.secure ?? process.env.NODE_ENV === 'production',\n      });\n    },\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,YAAY,OAAO,WAAkC;CAChE,MAAM,cAAc,MAAM,SAAS;AAEnC,0BAAyB,QAAyB,EAChD,iBAAiB,MAAM,OAAO,eAAe;AAC3C,cAAY,IAAI,MAAM,OAAO;GAC3B,GAAI,cAAc,EAAE;GACpB,MAAM,YAAY,QAAQ;GAC1B,UAAW,YAAY,YAAsB;GAC7C,UAAU,YAAY,YAAY;GAClC,QAAQ,YAAY,UAAU;GAC/B,CAAC;IAEL,CAAC"}

package/dist/esm/useDictionary.mjs

@@ -0,0 +1,43 @@
+'use client';
+
+import { useDictionary as useDictionary$1 } from "react-intlayer";
+
+//#region src/useDictionary.ts
+const navigatePath = (objectValue, path) => {
+	if (!path) return objectValue;
+	const parts = path.split(".");
+	let current = objectValue;
+	for (const part of parts) {
+		if (current === null || current === void 0 || typeof current !== "object") return;
+		current = current[part];
+	}
+	return current;
+};
+/**
+* Dictionary-accepting variant of `useTranslations`.
+*
+* Used internally by the SWC optimization: instead of looking up the dictionary
+* at runtime by key, the SWC plugin pre-imports the dictionary JSON at build time
+* and passes it directly here. This enables tree-shaking of unused locale content.
+*
+* @example (generated by SWC, not written manually)
+* import _abc from '.intlayer/dictionaries/about.json' with { type: 'json' };
+* const t = useDictionary(_abc);
+*/
+const useDictionary = (dictionary, namespacePrefix) => {
+	const content = useDictionary$1(dictionary);
+	const resolveKey = (key) => namespacePrefix ? `${namespacePrefix}.${key}` : key;
+	return Object.assign((lookup, params) => {
+		const rawValue = navigatePath(content, resolveKey(String(lookup)));
+		const str = String(rawValue ?? resolveKey(String(lookup)));
+		if (!params) return str;
+		return str.replace(/\{(\w+)\}/g, (_, k) => params[k] != null ? String(params[k]) : `{${k}}`);
+	}, {
+		has: (lookup) => navigatePath(content, resolveKey(String(lookup))) != null,
+		raw: (lookup) => navigatePath(content, resolveKey(String(lookup)))
+	});
+};
+
+//#endregion
+export { useDictionary };
+//# sourceMappingURL=useDictionary.mjs.map

package/dist/esm/useDictionary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionary.mjs","names":["useDictionaryBase"],"sources":["../../src/useDictionary.ts"],"sourcesContent":["'use client';\n\nimport type { ValidDotPathsFor } from '@intlayer/core/transpiler';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { useDictionary as useDictionaryBase } from 'react-intlayer';\n\nconst navigatePath = (objectValue: unknown, path: string): unknown => {\n  if (!path) return objectValue;\n  const parts = path.split('.');\n  let current: unknown = objectValue;\n  for (const part of parts) {\n    if (\n      current === null ||\n      current === undefined ||\n      typeof current !== 'object'\n    ) {\n      return undefined;\n    }\n    current = (current as Record<string, unknown>)[part];\n  }\n  return current;\n};\n\n/**\n * Dictionary-accepting variant of `useTranslations`.\n *\n * Used internally by the SWC optimization: instead of looking up the dictionary\n * at runtime by key, the SWC plugin pre-imports the dictionary JSON at build time\n * and passes it directly here. This enables tree-shaking of unused locale content.\n *\n * @example (generated by SWC, not written manually)\n * import _abc from '.intlayer/dictionaries/about.json' with { type: 'json' };\n * const t = useDictionary(_abc);\n */\nexport const useDictionary = <T extends Dictionary>(\n  dictionary: T,\n  namespacePrefix?: string\n) => {\n  const content = useDictionaryBase(dictionary);\n\n  const resolveKey = (key: string): string =>\n    namespacePrefix ? `${namespacePrefix}.${key}` : key;\n\n  return Object.assign(\n    <P extends ValidDotPathsFor<any>>(\n      lookup: P,\n      params?: Record<string, unknown>\n    ): string => {\n      const rawValue = navigatePath(content, resolveKey(String(lookup)));\n      const str = String(rawValue ?? resolveKey(String(lookup)));\n      if (!params) return str;\n      return str.replace(/\\{(\\w+)\\}/g, (_, k) =>\n        params[k] != null ? String(params[k]) : `{${k}}`\n      );\n    },\n    {\n      has: <P extends ValidDotPathsFor<any>>(lookup: P): boolean =>\n        navigatePath(content, resolveKey(String(lookup))) != null,\n      raw: <P extends ValidDotPathsFor<any>>(lookup: P): unknown =>\n        navigatePath(content, resolveKey(String(lookup))),\n    }\n  );\n};\n"],"mappings":";;;;;AAMA,MAAM,gBAAgB,aAAsB,SAA0B;AACpE,KAAI,CAAC,KAAM,QAAO;CAClB,MAAM,QAAQ,KAAK,MAAM,IAAI;CAC7B,IAAI,UAAmB;AACvB,MAAK,MAAM,QAAQ,OAAO;AACxB,MACE,YAAY,QACZ,YAAY,UACZ,OAAO,YAAY,SAEnB;AAEF,YAAW,QAAoC;;AAEjD,QAAO;;;;;;;;;;;;;AAcT,MAAa,iBACX,YACA,oBACG;CACH,MAAM,UAAUA,gBAAkB,WAAW;CAE7C,MAAM,cAAc,QAClB,kBAAkB,GAAG,gBAAgB,GAAG,QAAQ;AAElD,QAAO,OAAO,QAEV,QACA,WACW;EACX,MAAM,WAAW,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC;EAClE,MAAM,MAAM,OAAO,YAAY,WAAW,OAAO,OAAO,CAAC,CAAC;AAC1D,MAAI,CAAC,OAAQ,QAAO;AACpB,SAAO,IAAI,QAAQ,eAAe,GAAG,MACnC,OAAO,MAAM,OAAO,OAAO,OAAO,GAAG,GAAG,IAAI,EAAE,GAC/C;IAEH;EACE,MAAuC,WACrC,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC,IAAI;EACvD,MAAuC,WACrC,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC;EACpD,CACF"}

package/dist/esm/useDictionaryDynamic.mjs

@@ -0,0 +1,35 @@
+'use client';
+
+import { useDictionaryDynamic as useDictionaryDynamic$1 } from "react-intlayer";
+
+//#region src/useDictionaryDynamic.ts
+const navigatePath = (objectValue, path) => {
+	if (!path) return objectValue;
+	const parts = path.split(".");
+	let current = objectValue;
+	for (const part of parts) {
+		if (current === null || current === void 0 || typeof current !== "object") return;
+		current = current[part];
+	}
+	return current;
+};
+/**
+* Dynamic dictionary-accepting variant of `useTranslations`.
+*/
+const useDictionaryDynamic = (dictionaryPromise, key, namespacePrefix) => {
+	const content = useDictionaryDynamic$1(dictionaryPromise, key);
+	const resolveKey = (lookupKey) => namespacePrefix ? `${namespacePrefix}.${lookupKey}` : lookupKey;
+	return Object.assign((lookup, params) => {
+		const rawValue = navigatePath(content, resolveKey(String(lookup)));
+		const str = String(rawValue ?? resolveKey(String(lookup)));
+		if (!params) return str;
+		return str.replace(/\{(\w+)\}/g, (_, k) => params[k] != null ? String(params[k]) : `{${k}}`);
+	}, {
+		has: (lookup) => navigatePath(content, resolveKey(String(lookup))) != null,
+		raw: (lookup) => navigatePath(content, resolveKey(String(lookup)))
+	});
+};
+
+//#endregion
+export { useDictionaryDynamic };
+//# sourceMappingURL=useDictionaryDynamic.mjs.map

package/dist/esm/useDictionaryDynamic.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionaryDynamic.mjs","names":["useDictionaryDynamicBase"],"sources":["../../src/useDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport type { ValidDotPathsFor } from '@intlayer/core/transpiler';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type { StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport { useDictionaryDynamic as useDictionaryDynamicBase } from 'react-intlayer';\n\nconst navigatePath = (objectValue: unknown, path: string): unknown => {\n  if (!path) return objectValue;\n  const parts = path.split('.');\n  let current: unknown = objectValue;\n  for (const part of parts) {\n    if (\n      current === null ||\n      current === undefined ||\n      typeof current !== 'object'\n    ) {\n      return undefined;\n    }\n    current = (current as Record<string, unknown>)[part];\n  }\n  return current;\n};\n\n/**\n * Dynamic dictionary-accepting variant of `useTranslations`.\n */\nexport const useDictionaryDynamic = <\n  const T extends Dictionary,\n  const K extends string,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: K,\n  namespacePrefix?: string\n) => {\n  const content = useDictionaryDynamicBase<T, any>(\n    dictionaryPromise,\n    key as any\n  );\n\n  const resolveKey = (lookupKey: string): string =>\n    namespacePrefix ? `${namespacePrefix}.${lookupKey}` : lookupKey;\n\n  return Object.assign(\n    <P extends ValidDotPathsFor<any>>(\n      lookup: P,\n      params?: Record<string, unknown>\n    ): string => {\n      const rawValue = navigatePath(content, resolveKey(String(lookup)));\n      const str = String(rawValue ?? resolveKey(String(lookup)));\n      if (!params) return str;\n      return str.replace(/\\{(\\w+)\\}/g, (_, k) =>\n        params[k] != null ? String(params[k]) : `{${k}}`\n      );\n    },\n    {\n      has: <P extends ValidDotPathsFor<any>>(lookup: P): boolean =>\n        navigatePath(content, resolveKey(String(lookup))) != null,\n      raw: <P extends ValidDotPathsFor<any>>(lookup: P): unknown =>\n        navigatePath(content, resolveKey(String(lookup))),\n    }\n  );\n};\n"],"mappings":";;;;;AAOA,MAAM,gBAAgB,aAAsB,SAA0B;AACpE,KAAI,CAAC,KAAM,QAAO;CAClB,MAAM,QAAQ,KAAK,MAAM,IAAI;CAC7B,IAAI,UAAmB;AACvB,MAAK,MAAM,QAAQ,OAAO;AACxB,MACE,YAAY,QACZ,YAAY,UACZ,OAAO,YAAY,SAEnB;AAEF,YAAW,QAAoC;;AAEjD,QAAO;;;;;AAMT,MAAa,wBAIX,mBACA,KACA,oBACG;CACH,MAAM,UAAUA,uBACd,mBACA,IACD;CAED,MAAM,cAAc,cAClB,kBAAkB,GAAG,gBAAgB,GAAG,cAAc;AAExD,QAAO,OAAO,QAEV,QACA,WACW;EACX,MAAM,WAAW,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC;EAClE,MAAM,MAAM,OAAO,YAAY,WAAW,OAAO,OAAO,CAAC,CAAC;AAC1D,MAAI,CAAC,OAAQ,QAAO;AACpB,SAAO,IAAI,QAAQ,eAAe,GAAG,MACnC,OAAO,MAAM,OAAO,OAAO,OAAO,GAAG,GAAG,IAAI,EAAE,GAC/C;IAEH;EACE,MAAuC,WACrC,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC,IAAI;EACvD,MAAuC,WACrC,aAAa,SAAS,WAAW,OAAO,OAAO,CAAC,CAAC;EACpD,CACF"}

package/dist/esm/useTranslationsDictionary.mjs

@@ -0,0 +1,35 @@
+'use client';
+
+import { useDictionary } from "react-intlayer";
+
+//#region src/useTranslationsDictionary.ts
+/**
+* Dictionary-accepting variant of `useTranslations`.
+*
+* Used internally by the SWC optimization: instead of looking up the dictionary
+* at runtime by key, the SWC plugin pre-imports the dictionary JSON at build time
+* and passes it directly here. This enables tree-shaking of unused locale content.
+*
+* @example (generated by SWC, not written manually)
+* import _abc from '.intlayer/dictionaries/about.json' with { type: 'json' };
+* const t = useTranslationsDictionary(_abc);
+*/
+const useTranslationsDictionary = (dictionary, namespacePrefix) => {
+	const content = useDictionary(dictionary);
+	return (lookup, params) => {
+		const lookupKey = namespacePrefix ? `${namespacePrefix}.${String(lookup)}` : String(lookup);
+		const parts = lookupKey.split(".");
+		let current = content;
+		for (const part of parts) {
+			if (current == null) break;
+			current = current[part];
+		}
+		const str = String(current ?? lookupKey);
+		if (!params) return str;
+		return str.replace(/\{(\w+)\}/g, (_, k) => params[k] != null ? String(params[k]) : `{${k}}`);
+	};
+};
+
+//#endregion
+export { useTranslationsDictionary };
+//# sourceMappingURL=useTranslationsDictionary.mjs.map

package/dist/esm/useTranslationsDictionary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTranslationsDictionary.mjs","names":[],"sources":["../../src/useTranslationsDictionary.ts"],"sourcesContent":["'use client';\n\nimport type { ValidDotPathsFor } from '@intlayer/core/transpiler';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport { useDictionary } from 'react-intlayer';\n\n/**\n * Dictionary-accepting variant of `useTranslations`.\n *\n * Used internally by the SWC optimization: instead of looking up the dictionary\n * at runtime by key, the SWC plugin pre-imports the dictionary JSON at build time\n * and passes it directly here. This enables tree-shaking of unused locale content.\n *\n * @example (generated by SWC, not written manually)\n * import _abc from '.intlayer/dictionaries/about.json' with { type: 'json' };\n * const t = useTranslationsDictionary(_abc);\n */\nexport const useTranslationsDictionary = <T extends Dictionary>(\n  dictionary: T,\n  namespacePrefix?: string\n) => {\n  const content = useDictionary(dictionary);\n\n  return <P extends ValidDotPathsFor<any>>(\n    lookup: P,\n    params?: Record<string, unknown>\n  ): string => {\n    const lookupKey = namespacePrefix\n      ? `${namespacePrefix}.${String(lookup)}`\n      : String(lookup);\n    const parts = lookupKey.split('.');\n    let current: any = content;\n    for (const part of parts) {\n      if (current == null) break;\n      current = current[part];\n    }\n    const str = String(current ?? lookupKey);\n    if (!params) return str;\n    return str.replace(/\\{(\\w+)\\}/g, (_, k) =>\n      params[k] != null ? String(params[k]) : `{${k}}`\n    );\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAiBA,MAAa,6BACX,YACA,oBACG;CACH,MAAM,UAAU,cAAc,WAAW;AAEzC,SACE,QACA,WACW;EACX,MAAM,YAAY,kBACd,GAAG,gBAAgB,GAAG,OAAO,OAAO,KACpC,OAAO,OAAO;EAClB,MAAM,QAAQ,UAAU,MAAM,IAAI;EAClC,IAAI,UAAe;AACnB,OAAK,MAAM,QAAQ,OAAO;AACxB,OAAI,WAAW,KAAM;AACrB,aAAU,QAAQ;;EAEpB,MAAM,MAAM,OAAO,WAAW,UAAU;AACxC,MAAI,CAAC,OAAQ,QAAO;AACpB,SAAO,IAAI,QAAQ,eAAe,GAAG,MACnC,OAAO,MAAM,OAAO,OAAO,OAAO,GAAG,GAAG,IAAI,EAAE,GAC/C"}

package/dist/esm/useTranslationsDictionaryDynamic.mjs

@@ -0,0 +1,27 @@
+'use client';
+
+import { useDictionaryDynamic } from "react-intlayer";
+
+//#region src/useTranslationsDictionaryDynamic.ts
+/**
+* Dynamic dictionary-accepting variant of `useTranslations`.
+*/
+const useTranslationsDictionaryDynamic = (dictionaryPromise, key, namespacePrefix) => {
+	const content = useDictionaryDynamic(dictionaryPromise, key);
+	return (lookup, params) => {
+		const lookupKey = namespacePrefix ? `${namespacePrefix}.${String(lookup)}` : String(lookup);
+		const parts = lookupKey.split(".");
+		let current = content;
+		for (const part of parts) {
+			if (current == null) break;
+			current = current[part];
+		}
+		const str = String(current ?? lookupKey);
+		if (!params) return str;
+		return str.replace(/\{(\w+)\}/g, (_, k) => params[k] != null ? String(params[k]) : `{${k}}`);
+	};
+};
+
+//#endregion
+export { useTranslationsDictionaryDynamic };
+//# sourceMappingURL=useTranslationsDictionaryDynamic.mjs.map

package/dist/esm/useTranslationsDictionaryDynamic.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTranslationsDictionaryDynamic.mjs","names":[],"sources":["../../src/useTranslationsDictionaryDynamic.ts"],"sourcesContent":["'use client';\n\nimport type { ValidDotPathsFor } from '@intlayer/core/transpiler';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type { StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport { useDictionaryDynamic } from 'react-intlayer';\n\n/**\n * Dynamic dictionary-accepting variant of `useTranslations`.\n */\nexport const useTranslationsDictionaryDynamic = <\n  const T extends Dictionary,\n  const K extends string,\n>(\n  dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>,\n  key: K,\n  namespacePrefix?: string\n) => {\n  const content = useDictionaryDynamic<T, any>(dictionaryPromise, key as any);\n\n  return <P extends ValidDotPathsFor<any>>(\n    lookup: P,\n    params?: Record<string, unknown>\n  ): string => {\n    const lookupKey = namespacePrefix\n      ? `${namespacePrefix}.${String(lookup)}`\n      : String(lookup);\n    const parts = lookupKey.split('.');\n    let current: any = content;\n    for (const part of parts) {\n      if (current == null) break;\n      current = current[part];\n    }\n    const str = String(current ?? lookupKey);\n    if (!params) return str;\n    return str.replace(/\\{(\\w+)\\}/g, (_, k) =>\n      params[k] != null ? String(params[k]) : `{${k}}`\n    );\n  };\n};\n"],"mappings":";;;;;;;;AAUA,MAAa,oCAIX,mBACA,KACA,oBACG;CACH,MAAM,UAAU,qBAA6B,mBAAmB,IAAW;AAE3E,SACE,QACA,WACW;EACX,MAAM,YAAY,kBACd,GAAG,gBAAgB,GAAG,OAAO,OAAO,KACpC,OAAO,OAAO;EAClB,MAAM,QAAQ,UAAU,MAAM,IAAI;EAClC,IAAI,UAAe;AACnB,OAAK,MAAM,QAAQ,OAAO;AACxB,OAAI,WAAW,KAAM;AACrB,aAAU,QAAQ;;EAEpB,MAAM,MAAM,OAAO,WAAW,UAAU;AACxC,MAAI,CAAC,OAAQ,QAAO;AACpB,SAAO,IAAI,QAAQ,eAAe,GAAG,MACnC,OAAO,MAAM,OAAO,OAAO,OAAO,GAAG,GAAG,IAAI,EAAE,GAC/C"}

package/dist/types/client/NextIntlClientProvider.d.ts

@@ -0,0 +1,28 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import { NextIntlClientProvider as NextIntlClientProvider$1 } from "next-intl";
+import { ComponentProps } from "react";
+
+//#region src/client/NextIntlClientProvider.d.ts
+/**
+ * Drop-in for next-intl's `NextIntlClientProvider`.
+ * `messages`, `timeZone`, and `now` are accepted for API compatibility
+ * but have no effect — Intlayer uses its own compiled dictionaries.
+ */
+declare const NextIntlClientProvider: typeof NextIntlClientProvider$1;
+/**
+ *
+ */
+type NextIntlClientProviderProps = Omit<ComponentProps<typeof NextIntlClientProvider$1>, 'messages'> & {
+  /**
+   * @deprecated
+   * has no use case with intlayer. Messages are loaded automatically under the hood for bundle optimization reason
+   */
+  messages?: never;
+  /**
+   * locale
+   */
+  locale: LocalesValues;
+};
+//#endregion
+export { NextIntlClientProvider, NextIntlClientProviderProps };
+//# sourceMappingURL=NextIntlClientProvider.d.ts.map

package/dist/types/client/NextIntlClientProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NextIntlClientProvider.d.ts","names":[],"sources":["../../../src/client/NextIntlClientProvider.tsx"],"mappings":";;;;;;;AAeA;;;cAAa,sBAAA,SAA+B,wBAAA;;AAgC5C;;KAAY,2BAAA,GAA8B,IAAA,CACxC,cAAA,QAAsB,wBAAA;EAAA;;;;EAOtB,QAAA;EAIqB;;;EAArB,MAAA,EAAQ,aAAA;AAAA"}

package/dist/types/client/helpers.d.ts

@@ -0,0 +1,45 @@
+import { IntlProvider as IntlProvider$1, useFormatter as useFormatter$1, useMessages as useMessages$1, useNow as useNow$1, useTimeZone as useTimeZone$1 } from "next-intl";
+
+//#region src/client/helpers.d.ts
+/**
+ * Drop-in for next-intl's `useNow`.
+ * Returns the current `Date`. The `updateInterval` option is ignored.
+ */
+declare const useNow: typeof useNow$1;
+/**
+ * Drop-in for next-intl's `useTimeZone`.
+ * Returns the system time zone resolved from `Intl.DateTimeFormat`.
+ */
+declare const useTimeZone: typeof useTimeZone$1;
+/**
+ * Drop-in for next-intl's `useMessages`.
+ *
+ * @deprecated useMessages has no use case with intlayer.
+ * Messages are loaded automatically under the hood.
+ * @returns An empty object.
+ */
+declare const useMessages: typeof useMessages$1;
+/**
+ * Drop-in for next-intl's `useFormatter`.
+ * Returns locale-aware formatters backed by the native `Intl.*` APIs:
+ * `dateTime`, `number`, `dateTimeRange`, `relativeTime`, `list`, and
+ * `displayName`.
+ */
+declare const useFormatter: typeof useFormatter$1;
+/**
+ * Drop-in for next-intl's `IntlProvider`.
+ * Renders children as-is — Intlayer provides its own context via
+ * `IntlayerClientProvider`.
+ *
+ * @deprecated IntlProvider has no use case with intlayer.
+ * Use `IntlayerClientProvider` or `NextIntlClientProvider` instead.
+ */
+declare const IntlProvider: typeof IntlProvider$1;
+/**
+ * @internal Not part of the public next-intl API surface; provided for
+ * internal compatibility shims only.
+ */
+declare const useExtracted: (..._args: unknown[]) => {};
+//#endregion
+export { IntlProvider, useExtracted, useFormatter, useMessages, useNow, useTimeZone };
+//# sourceMappingURL=helpers.d.ts.map

package/dist/types/client/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","names":[],"sources":["../../../src/client/helpers.tsx"],"mappings":";;;;;AAoBA;;cAAa,MAAA,SAAe,QAAA;;;AAM5B;;cAAa,WAAA,SAAoB,aAAA;;;AAUjC;;;;;cAAa,WAAA,SAAoB,aAAA;;;;;AAmCjC;;cAlBa,YAAA,SAAqB,cAAA;;;AA0BlC;;;;;;cARa,YAAA,SAAqB,cAAA;;;;;cAQrB,YAAA,MAAmB,KAAA"}

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

@@ -0,0 +1,7 @@
+import { NextIntlClientProvider, NextIntlClientProviderProps } from "./NextIntlClientProvider.js";
+import { IntlProvider, useExtracted, useFormatter, useMessages, useNow, useTimeZone } from "./helpers.js";
+import { useDictionary } from "../useDictionary.js";
+import { useDictionaryDynamic } from "../useDictionaryDynamic.js";
+import { useLocale } from "./useLocale.js";
+import { useTranslations } from "./useTranslations.js";
+export { IntlProvider, NextIntlClientProvider, type NextIntlClientProviderProps, useDictionary, useDictionaryDynamic, useExtracted, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };

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

@@ -0,0 +1,10 @@
+import { useLocale as useLocale$1 } from "next-intl";
+
+//#region src/client/useLocale.d.ts
+/**
+ * Drop-in for next-intl's `useLocale`.
+ */
+declare const useLocale: typeof useLocale$1;
+//#endregion
+export { useLocale };
+//# sourceMappingURL=useLocale.d.ts.map

package/dist/types/client/useLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";;;;;AAQA;cAAa,SAAA,SAAkB,WAAA"}

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

@@ -0,0 +1,74 @@
+import { MarkupChunkRenderer, RichChunkRenderer } from "../createTranslator.js";
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
+import { ReactNode } from "react";
+import { ValidDotPathsFor } from "@intlayer/core/transpiler";
+
+//#region src/client/useTranslations.d.ts
+/**
+ * The translation function returned by {@link useTranslations}.
+ *
+ * When the namespace is a bare dictionary key, `key` is validated against the
+ * dictionary's dot-paths. When the namespace is a nested scope
+ * (`'about.counter'`), `key` is a relative `string` path.
+ *
+ * Beyond the call signature, the function exposes:
+ * - `has(key)` — returns `true` when the key exists in the namespace.
+ * - `raw(key)` — returns the unprocessed content value.
+ * - `rich(key, values)` — resolves `<tag>chunks</tag>` markup to React nodes.
+ * - `markup(key, values)` — resolves `<tag>chunks</tag>` markup to a string.
+ */
+type TranslateFunction<N extends DictionaryKeys> = {
+  /** Translate a key to a string, with optional ICU interpolation params. */<P extends ValidDotPathsFor<N>>(key: P, params?: Record<string, unknown>): string; /** Returns `true` if the given key exists in the namespace. */
+  has<P extends ValidDotPathsFor<N>>(key: P): boolean; /** Returns the raw unprocessed content for the given key. */
+  raw<P extends ValidDotPathsFor<N>>(key: P): unknown; /** Resolves rich-text markup, mapping tags through React renderers. */
+  rich<P extends ValidDotPathsFor<N>>(key: P, values?: Record<string, RichChunkRenderer | ReactNode>): ReactNode; /** Resolves rich-text markup, mapping tags through string renderers. */
+  markup<P extends ValidDotPathsFor<N>>(key: P, values?: Record<string, MarkupChunkRenderer | string | number>): string;
+};
+/** Loosely-typed function returned for nested `'dict.scope'` namespaces. */
+type LooseTranslateFunction = {
+  (key: string, params?: Record<string, unknown>): string;
+  has(key: string): boolean;
+  raw(key: string): unknown;
+  rich(key: string, values?: Record<string, RichChunkRenderer | ReactNode>): ReactNode;
+  markup(key: string, values?: Record<string, MarkupChunkRenderer | string | number>): string;
+};
+/**
+ * Overload set for {@link useTranslations}:
+ *
+ * 1. A bare dictionary key → fully-typed `t()` (autocompleted dot-paths).
+ * 2. A nested namespace `'dictionary.sub.scope'` → `t()` accepts relative
+ *    `string` paths, matching next-intl's scoped-namespace behaviour.
+ * 3. No namespace → root scope; the first segment of each key designates
+ *    the dictionary (`t('about.title')`).
+ */
+type UseTranslations = {
+  <N extends DictionaryKeys>(namespace: N): TranslateFunction<N>;
+  (namespace: `${string}.${string}`): LooseTranslateFunction;
+  (): LooseTranslateFunction;
+};
+/**
+ * Drop-in for next-intl's `useTranslations`.
+ *
+ * Messages support ICU MessageFormat syntax: simple arguments (`{name}`),
+ * plural (`{count, plural, one {…} other {…}}`, `#`), select, and formatted
+ * arguments (`{value, number}`). Rich text is available through `t.rich()`
+ * and `t.markup()`.
+ *
+ * @example
+ * ```tsx
+ * const t = useTranslations('about');
+ * t('counter.label'); // ✓ typed
+ * t('items', { count: 3 }); // ICU plural
+ *
+ * // Scoped to a nested object (next-intl idiom)
+ * const t = useTranslations('about.counter');
+ * t('label'); // resolves about → counter.label
+ *
+ * // Rich text
+ * t.rich('terms', { link: (chunks) => <a href="/terms">{chunks}</a> });
+ * ```
+ */
+declare const useTranslations: UseTranslations;
+//#endregion
+export { useTranslations };
+//# sourceMappingURL=useTranslations.d.ts.map

package/dist/types/client/useTranslations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTranslations.d.ts","names":[],"sources":["../../../src/client/useTranslations.ts"],"mappings":";;;;;;;;AAa6B;;;;;;;;;;;KAexB,iBAAA,WAA4B,cAAA;EASjB,sFAPH,gBAAA,CAAiB,CAAA,GAC1B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,4BAOqB;EAJhC,GAAA,WAAc,gBAAA,CAAiB,CAAA,GAAI,GAAA,EAAK,CAAA,YAKjC;EAHP,GAAA,WAAc,gBAAA,CAAiB,CAAA,GAAI,GAAA,EAAK,CAAA,YAIM;EAF9C,IAAA,WAAe,gBAAA,CAAiB,CAAA,GAC9B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,SAAe,iBAAA,GAAoB,SAAA,IAC3C,SAAA,EAAA;EAEH,MAAA,WAAiB,gBAAA,CAAiB,CAAA,GAChC,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,SAAe,mBAAA;AAAA;;KAKvB,sBAAA;EAAA,CACF,GAAA,UAAa,MAAA,GAAS,MAAA;EACvB,GAAA,CAAI,GAAA;EACJ,GAAA,CAAI,GAAA;EACJ,IAAA,CACE,GAAA,UACA,MAAA,GAAS,MAAA,SAAe,iBAAA,GAAoB,SAAA,IAC3C,SAAA;EACH,MAAA,CACE,GAAA,UACA,MAAA,GAAS,MAAA,SAAe,mBAAA;AAAA;;;;;;;;;;KAavB,eAAA;EAAA,WACQ,cAAA,EAAgB,SAAA,EAAW,CAAA,GAAI,iBAAA,CAAkB,CAAA;EAAA,CAC3D,SAAA,0BAAmC,sBAAA;EAAA,IAChC,sBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;cAyBO,eAAA,EAOP,eAAA"}

package/dist/types/createFormatter.d.ts

@@ -0,0 +1,15 @@
+import { useFormatter } from "next-intl";
+
+//#region src/createFormatter.d.ts
+/** The formatter object shape exposed by next-intl. */
+type Formatter = ReturnType<typeof useFormatter>;
+/**
+ * Builds a next-intl compatible formatter backed by the native `Intl.*`
+ * APIs for the given locale.
+ *
+ * Shared by `useFormatter` (client) and `getFormatter` (server).
+ */
+declare const createFormatter: (locale: string) => Formatter;
+//#endregion
+export { Formatter, createFormatter };
+//# sourceMappingURL=createFormatter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createFormatter.d.ts","names":[],"sources":["../../src/createFormatter.ts"],"mappings":";;;;KAGY,SAAA,GAAY,UAAA,QAAkB,YAAA;AAA1C;;;;;AAsBA;AAtBA,cAsBa,eAAA,GAAmB,MAAA,aAAiB,SAAA"}