@intlayer/next-intl 9.0.0-canary.2 → 9.0.0-canary.4

package/dist/esm/server/getRequestConfig.mjs

@@ -0,0 +1,25 @@
+import { log } from "@intlayer/config/built";
+import { CYAN } from "@intlayer/config/colors";
+import { colorize, getAppLogger } from "@intlayer/config/logger";
+
+//#region src/server/getRequestConfig.ts
+/**
+* Drop-in for next-intl's `getRequestConfig`.
+*
+* In next-intl this registers the per-request config (locale + messages) read
+* by its own plugin. With intlayer the locale is resolved from routing /
+* storage and messages come from compiled dictionaries, so the returned config
+* is never consumed — this is an identity passthrough kept so existing
+* `i18n/request.ts` files keep resolving and type-checking.
+*
+* @deprecated getRequestConfig has no use case with intlayer. The locale and
+* messages are resolved automatically; the file can be removed.
+*/
+const getRequestConfig = (createRequestConfig) => {
+	getAppLogger({ log })(`${colorize("getRequestConfig", CYAN)} has no use case with intlayer. The locale and messages are resolved automatically; the i18n/request.ts file can be removed`);
+	return createRequestConfig;
+};
+
+//#endregion
+export { getRequestConfig as default, getRequestConfig };
+//# sourceMappingURL=getRequestConfig.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getRequestConfig.mjs","names":[],"sources":["../../../src/server/getRequestConfig.ts"],"sourcesContent":["import { log } from '@intlayer/config/built';\nimport { CYAN } from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport type { getRequestConfig as _getRequestConfig } from 'next-intl/server';\n\n/**\n * Drop-in for next-intl's `getRequestConfig`.\n *\n * In next-intl this registers the per-request config (locale + messages) read\n * by its own plugin. With intlayer the locale is resolved from routing /\n * storage and messages come from compiled dictionaries, so the returned config\n * is never consumed — this is an identity passthrough kept so existing\n * `i18n/request.ts` files keep resolving and type-checking.\n *\n * @deprecated getRequestConfig has no use case with intlayer. The locale and\n * messages are resolved automatically; the file can be removed.\n */\nexport const getRequestConfig: typeof _getRequestConfig = (\n  createRequestConfig\n) => {\n  if (process.env.NODE_ENV === 'development') {\n    const appLogger = getAppLogger({ log });\n    appLogger(\n      `${colorize('getRequestConfig', CYAN)} has no use case with intlayer. The locale and messages are resolved automatically; the i18n/request.ts file can be removed`\n    );\n  }\n\n  return createRequestConfig;\n};\n\nexport default getRequestConfig;\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,MAAa,oBACX,wBACG;AAGD,CADkB,aAAa,EAAE,KAAK,CAC7B,CACP,GAAG,SAAS,oBAAoB,KAAK,CAAC,6HACvC;AAGH,QAAO"}

package/dist/esm/server/getTranslations.mjs

@@ -1,5 +1,5 @@
 import { getLocale } from "./getLocale.mjs";
-import { createTranslator } from "../createTranslator.mjs";
+import { createTranslator } from "@intlayer/use-intl";
 
 //#region src/server/getTranslations.ts
 /**
@@ -10,8 +10,9 @@ import { createTranslator } from "../createTranslator.mjs";
 * 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.
+* Resolves the active locale from the current request (or the `locale` option)
+* and delegates to `@intlayer/use-intl`'s `createTranslator`, the same runtime
+* that backs the client `useTranslations`.
 *
 * @example
 * ```ts
@@ -36,7 +37,10 @@ const getTranslations = (async (namespaceOrOptions) => {
 		namespace = namespaceOrOptions.namespace;
 		localeOverride = namespaceOrOptions.locale;
 	} else namespace = namespaceOrOptions;
-	return createTranslator(localeOverride ?? await getLocale(), namespace);
+	return createTranslator({
+		locale: localeOverride ?? await getLocale(),
+		namespace
+	});
 });
 
 //#endregion

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

@@ -1 +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"}
+{"version":3,"file":"getTranslations.mjs","names":[],"sources":["../../../src/server/getTranslations.ts"],"sourcesContent":["import type {\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport {\n  createTranslator,\n  type LooseTranslateFunction,\n  type TranslateFunction,\n} from '@intlayer/use-intl';\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 * 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 *\n * The translate function shape (`t`, `t.rich`, `t.markup`, `t.raw`, `t.has`)\n * is shared with `@intlayer/use-intl`.\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 * Resolves the active locale from the current request (or the `locale` option)\n * and delegates to `@intlayer/use-intl`'s `createTranslator`, the same runtime\n * that backs the client `useTranslations`.\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: locale as LocalesValues, namespace });\n}) as GetTranslations;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEA,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,iBAAiB;EAAE,QAFX,kBAAmB,MAAM,WAAW;EAEQ;EAAW,CAAC"}

package/dist/esm/server/helpers.mjs

@@ -1,13 +1,14 @@
-import { createFormatter } from "../createFormatter.mjs";
 import { getLocale } from "./getLocale.mjs";
+import { createFormatter } from "@intlayer/use-intl";
 
 //#region src/server/helpers.ts
 /**
 * Drop-in for next-intl's server `getFormatter()`.
-* Returns locale-aware formatters backed by the native `Intl.*` APIs.
+* Returns locale-aware formatters backed by the native `Intl.*` APIs,
+* built by `@intlayer/use-intl`'s `createFormatter`.
 */
 const getFormatter = (async (options) => {
-	return createFormatter(options?.locale ?? await getLocale());
+	return createFormatter({ locale: options?.locale ?? await getLocale() });
 });
 /**
 * Drop-in for next-intl's server `getNow()`.

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

@@ -1 +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"}
+{"version":3,"file":"helpers.mjs","names":[],"sources":["../../../src/server/helpers.ts"],"sourcesContent":["import { createFormatter } from '@intlayer/use-intl';\nimport type {\n  getFormatter as _getFormatter,\n  getNow as _getNow,\n  getTimeZone as _getTimeZone,\n} from 'next-intl/server';\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 * built by `@intlayer/use-intl`'s `createFormatter`.\n */\nexport const getFormatter: typeof _getFormatter = (async (options?: {\n  locale?: string;\n}) => {\n  const locale = options?.locale ?? (await getLocale());\n  return createFormatter({ locale: 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":";;;;;;;;;AAaA,MAAa,gBAAsC,OAAO,YAEpD;AAEJ,QAAO,gBAAgB,EAAE,QADV,SAAS,UAAW,MAAM,WAAW,EACD,CAAC;;;;;;AAOtD,MAAa,UAA0B,4BACrC,IAAI,MAAM;;;;;AAMZ,MAAa,eAAoC,YAC/C,KAAK,gBAAgB,CAAC,iBAAiB,CAAC"}

package/dist/esm/server/index.mjs

@@ -2,8 +2,10 @@ import { getLocale } from "./getLocale.mjs";
 import { getDictionary } from "../getDictionary.mjs";
 import { getDictionaryDynamic } from "../getDictionaryDynamic.mjs";
 import { getFormatter, getNow, getTimeZone } from "./helpers.mjs";
+import getRequestConfig from "./getRequestConfig.mjs";
+import { setRequestLocale } from "./setRequestLocale.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 };
+export { getDictionary, getDictionaryDynamic, getFormatter, getLocale, getMessages, getNow, getRequestConfig, getTimeZone, getTranslations, setLocale, setRequestLocale };

package/dist/esm/server/requestLocaleCache.mjs

@@ -0,0 +1,33 @@
+import { cache } from "react";
+
+//#region src/server/requestLocaleCache.ts
+/**
+* Request-scoped holder for the locale provided through {@link setRequestLocale}.
+*
+* next-intl resolves the active locale per request from the `[locale]` route
+* segment, which the app forwards via `setRequestLocale(locale)`. React's
+* `cache()` gives a per-request singleton (the same trick next-intl uses in its
+* own `RequestLocaleCache`), so the value set in the layout/page is readable by
+* the other server APIs (`getLocale`, `getTranslations`, …) during the same
+* render.
+*
+* @see https://github.com/vercel/next.js/discussions/58862
+*/
+const getRequestLocaleHolder = cache(() => ({ locale: void 0 }));
+/**
+* Read the locale stored for the current request, or `undefined` when
+* `setRequestLocale` has not been called.
+*/
+const getCachedRequestLocale = () => getRequestLocaleHolder().locale;
+/**
+* Store the locale for the current request. Called by `setRequestLocale`.
+*
+* @param locale - The locale resolved from the `[locale]` route segment.
+*/
+const setCachedRequestLocale = (locale) => {
+	getRequestLocaleHolder().locale = locale;
+};
+
+//#endregion
+export { getCachedRequestLocale, setCachedRequestLocale };
+//# sourceMappingURL=requestLocaleCache.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"requestLocaleCache.mjs","names":[],"sources":["../../../src/server/requestLocaleCache.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { cache } from 'react';\n\n/**\n * Request-scoped holder for the locale provided through {@link setRequestLocale}.\n *\n * next-intl resolves the active locale per request from the `[locale]` route\n * segment, which the app forwards via `setRequestLocale(locale)`. React's\n * `cache()` gives a per-request singleton (the same trick next-intl uses in its\n * own `RequestLocaleCache`), so the value set in the layout/page is readable by\n * the other server APIs (`getLocale`, `getTranslations`, …) during the same\n * render.\n *\n * @see https://github.com/vercel/next.js/discussions/58862\n */\nconst getRequestLocaleHolder = cache((): { locale?: LocalesValues } => ({\n  locale: undefined,\n}));\n\n/**\n * Read the locale stored for the current request, or `undefined` when\n * `setRequestLocale` has not been called.\n */\nexport const getCachedRequestLocale = (): LocalesValues | undefined =>\n  getRequestLocaleHolder().locale;\n\n/**\n * Store the locale for the current request. Called by `setRequestLocale`.\n *\n * @param locale - The locale resolved from the `[locale]` route segment.\n */\nexport const setCachedRequestLocale = (locale: LocalesValues): void => {\n  getRequestLocaleHolder().locale = locale;\n};\n"],"mappings":";;;;;;;;;;;;;;;AAeA,MAAM,yBAAyB,aAAyC,EACtE,QAAQ,QACT,EAAE;;;;;AAMH,MAAa,+BACX,wBAAwB,CAAC;;;;;;AAO3B,MAAa,0BAA0B,WAAgC;AACrE,yBAAwB,CAAC,SAAS"}

package/dist/esm/server/setRequestLocale.mjs

@@ -0,0 +1,32 @@
+import { setCachedRequestLocale } from "./requestLocaleCache.mjs";
+
+//#region src/server/setRequestLocale.ts
+/**
+* Drop-in for next-intl's `setRequestLocale`.
+*
+* In next-intl this stores the locale (typically the `[locale]` route segment)
+* in a request-scoped cache so the rest of the request can render in that
+* locale and opt into static rendering. The compat keeps the same contract:
+* the locale is stored per-request and read back by `getLocale()` (and, through
+* it, `getTranslations` / `getDictionary` / metadata). This is what makes the
+* per-request locale — and therefore the locale switcher — work without relying
+* on a cookie.
+*
+* @param locale - The locale resolved from the `[locale]` route segment.
+*
+* @example
+* ```ts
+* export default async function LocaleLayout({ params }) {
+*   const { locale } = await params;
+*   setRequestLocale(locale);
+*   // …
+* }
+* ```
+*/
+const setRequestLocale = (locale) => {
+	setCachedRequestLocale(locale);
+};
+
+//#endregion
+export { setRequestLocale };
+//# sourceMappingURL=setRequestLocale.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setRequestLocale.mjs","names":[],"sources":["../../../src/server/setRequestLocale.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport type { setRequestLocale as _setRequestLocale } from 'next-intl/server';\nimport { setCachedRequestLocale } from './requestLocaleCache';\n\n/**\n * Drop-in for next-intl's `setRequestLocale`.\n *\n * In next-intl this stores the locale (typically the `[locale]` route segment)\n * in a request-scoped cache so the rest of the request can render in that\n * locale and opt into static rendering. The compat keeps the same contract:\n * the locale is stored per-request and read back by `getLocale()` (and, through\n * it, `getTranslations` / `getDictionary` / metadata). This is what makes the\n * per-request locale — and therefore the locale switcher — work without relying\n * on a cookie.\n *\n * @param locale - The locale resolved from the `[locale]` route segment.\n *\n * @example\n * ```ts\n * export default async function LocaleLayout({ params }) {\n *   const { locale } = await params;\n *   setRequestLocale(locale);\n *   // …\n * }\n * ```\n */\nexport const setRequestLocale: typeof _setRequestLocale = (locale): void => {\n  setCachedRequestLocale(locale as LocalesValues);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,oBAA8C,WAAiB;AAC1E,wBAAuB,OAAwB"}

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

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

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

@@ -1,7 +1,4 @@
 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";
+import { IntlProvider, _useExtracted as useExtracted, useDictionary, useDictionaryDynamic, useFormatter, useMessages, useNow, useTimeZone, useTranslations } from "@intlayer/use-intl";
 export { IntlProvider, NextIntlClientProvider, type NextIntlClientProviderProps, useDictionary, useDictionaryDynamic, useExtracted, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };

package/dist/types/index.d.ts

@@ -1,9 +1,6 @@
 import { NextIntlClientProvider, NextIntlClientProviderProps } from "./client/NextIntlClientProvider.js";
-import { IntlProvider, useExtracted, useFormatter, useMessages, useNow, useTimeZone } from "./client/helpers.js";
-import { useDictionary } from "./useDictionary.js";
-import { useDictionaryDynamic } from "./useDictionaryDynamic.js";
 import { useLocale } from "./client/useLocale.js";
-import { useTranslations } from "./client/useTranslations.js";
-import { hasLocale } from "./hasLocale.js";
+import { IntlProvider, useDictionary, useDictionaryDynamic, useExtracted, useFormatter, useMessages, useNow, useTimeZone, useTranslations } from "./client/index.js";
 import { Routing, defineRouting } from "./routing.js";
-export { IntlProvider, NextIntlClientProvider, NextIntlClientProviderProps, type Routing, defineRouting, hasLocale, useDictionary, useDictionaryDynamic, useExtracted, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };
+import { IntlError, IntlErrorCode, createFormatter, createTranslator, hasLocale, initializeConfig } from "@intlayer/use-intl";
+export { IntlError, IntlErrorCode, IntlProvider, NextIntlClientProvider, NextIntlClientProviderProps, type Routing, createFormatter, createTranslator, defineRouting, hasLocale, initializeConfig, useDictionary, useDictionaryDynamic, useExtracted, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };

package/dist/types/server/getLocale.d.ts

@@ -3,6 +3,15 @@ import { getLocale as getLocale$1 } from "next-intl/server";
 //#region src/server/getLocale.d.ts
 /**
  * Drop-in for next-intl's `getLocale()` server function.
+ *
+ * Resolution order mirrors next-intl's per-request model:
+ *
+ * 1. The locale forwarded through `setRequestLocale(locale)` (the `[locale]`
+ *    route segment) — the source of truth for URL-driven routing. This is what
+ *    keeps server-rendered content and the locale switcher in sync with the URL
+ *    instead of a stale cookie.
+ * 2. Otherwise Intlayer's own resolution (cookie / header / Accept-Language),
+ *    for apps that drive the locale from storage rather than the route.
  */
 declare const getLocale: typeof getLocale$1;
 //#endregion

package/dist/types/server/getLocale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/server/getLocale.ts"],"mappings":";;;;;AAMA;cAAa,SAAA,SAAkB,WAAA"}
+{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/server/getLocale.ts"],"mappings":";;;;;AAgBA;;;;;;;;;;cAAa,SAAA,SAAkB,WAAA"}

package/dist/types/server/getRequestConfig.d.ts

@@ -0,0 +1,19 @@
+import { getRequestConfig as getRequestConfig$1 } from "next-intl/server";
+
+//#region src/server/getRequestConfig.d.ts
+/**
+ * Drop-in for next-intl's `getRequestConfig`.
+ *
+ * In next-intl this registers the per-request config (locale + messages) read
+ * by its own plugin. With intlayer the locale is resolved from routing /
+ * storage and messages come from compiled dictionaries, so the returned config
+ * is never consumed — this is an identity passthrough kept so existing
+ * `i18n/request.ts` files keep resolving and type-checking.
+ *
+ * @deprecated getRequestConfig has no use case with intlayer. The locale and
+ * messages are resolved automatically; the file can be removed.
+ */
+declare const getRequestConfig: typeof getRequestConfig$1;
+//#endregion
+export { getRequestConfig as default, getRequestConfig };
+//# sourceMappingURL=getRequestConfig.d.ts.map

package/dist/types/server/getRequestConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRequestConfig.d.ts","names":[],"sources":["../../../src/server/getRequestConfig.ts"],"mappings":";;;;;AAiBA;;;;;;;;;;cAAa,gBAAA,SAAyB,kBAAA"}

package/dist/types/server/getTranslations.d.ts

@@ -1,7 +1,5 @@
-import { MarkupChunkRenderer, RichChunkRenderer } from "../createTranslator.js";
 import { DictionaryKeys, LocalesValues } from "@intlayer/types/module_augmentation";
-import { ReactNode } from "react";
-import { ValidDotPathsFor } from "@intlayer/core/transpiler";
+import { LooseTranslateFunction, TranslateFunction } from "@intlayer/use-intl";
 
 //#region src/server/getTranslations.d.ts
 /**
@@ -11,30 +9,6 @@ type GetTranslationsOptions<N extends DictionaryKeys> = {
   /** The dictionary namespace to scope translations to. */namespace?: N; /** Override the locale instead of reading it from the current request. */
   locale?: LocalesValues;
 };
-/**
- * The translation function returned by {@link getTranslations}.
- *
- * Beyond the plain call signature, the function exposes:
- * - `has(key)` — returns `true` when the key exists in the namespace.
- * - `raw(key)` — returns the unprocessed message 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 message 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 getTranslations}:
  *
@@ -45,6 +19,9 @@ type LooseTranslateFunction = {
  *    `string` paths, matching next-intl's scoped-namespace behaviour.
  * 4. No namespace → root scope; the first segment of each key designates
  *    the dictionary (`t('about.title')`).
+ *
+ * The translate function shape (`t`, `t.rich`, `t.markup`, `t.raw`, `t.has`)
+ * is shared with `@intlayer/use-intl`.
  */
 type GetTranslations = {
   <N extends DictionaryKeys>(namespace: N): Promise<TranslateFunction<N>>;
@@ -60,8 +37,9 @@ type GetTranslations = {
  * 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.
+ * Resolves the active locale from the current request (or the `locale` option)
+ * and delegates to `@intlayer/use-intl`'s `createTranslator`, the same runtime
+ * that backs the client `useTranslations`.
  *
  * @example
  * ```ts

package/dist/types/server/getTranslations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getTranslations.d.ts","names":[],"sources":["../../../src/server/getTranslations.ts"],"mappings":";;;;;;;;AAU6B;KAMxB,sBAAA,WAAiC,cAAA;EAAX,yDAEzB,SAAA,GAAY,CAAA,EAAA;EAEZ,MAAA,GAAS,aAAA;AAAA;;;;;;;;;;KAYN,iBAAA,WAA4B,cAAA;EAAX,sFAET,gBAAA,CAAiB,CAAA,GAC1B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,4BAJoB;EAO/B,GAAA,WAAc,gBAAA,CAAiB,CAAA,GAAI,GAAA,EAAK,CAAA,YAL7B;EAOX,GAAA,WAAc,gBAAA,CAAiB,CAAA,GAAI,GAAA,EAAK,CAAA,YAL7B;EAOX,IAAA,WAAe,gBAAA,CAAiB,CAAA,GAC9B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,SAAe,iBAAA,GAAoB,SAAA,IAC3C,SAAA,EAPW;EASd,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;;;;;;;;;;;;KAevB,eAAA;EAAA,WACQ,cAAA,EAAgB,SAAA,EAAW,CAAA,GAAI,OAAA,CAAQ,iBAAA,CAAkB,CAAA;EAAA,WACzD,cAAA,EACT,OAAA,EAAS,sBAAA,CAAuB,CAAA,IAC/B,OAAA,CAAQ,iBAAA,CAAkB,CAAA;EAAA,CAC5B,SAAA,0BAAmC,OAAA,CAAQ,sBAAA;EAAA,IACxC,OAAA,CAAQ,sBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BD,eAAA,EAAiB,eAAA"}
+{"version":3,"file":"getTranslations.d.ts","names":[],"sources":["../../../src/server/getTranslations.ts"],"mappings":";;;;;;AAQ4B;KAMvB,sBAAA,WAAiC,cAAA;EAAX,yDAEzB,SAAA,GAAY,CAAA,EAAA;EAEZ,MAAA,GAAS,aAAA;AAAA;;;;;;;;;;AAAa;;;;;KAiBnB,eAAA;EAAA,WACQ,cAAA,EAAgB,SAAA,EAAW,CAAA,GAAI,OAAA,CAAQ,iBAAA,CAAkB,CAAA;EAAA,WACzD,cAAA,EACT,OAAA,EAAS,sBAAA,CAAuB,CAAA,IAC/B,OAAA,CAAQ,iBAAA,CAAkB,CAAA;EAAA,CAC5B,SAAA,0BAAmC,OAAA,CAAQ,sBAAA;EAAA,IACxC,OAAA,CAAQ,sBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BD,eAAA,EAAiB,eAAA"}

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

@@ -3,7 +3,8 @@ import { getFormatter as getFormatter$1, getNow as getNow$1, getTimeZone as getT
 //#region src/server/helpers.d.ts
 /**
  * Drop-in for next-intl's server `getFormatter()`.
- * Returns locale-aware formatters backed by the native `Intl.*` APIs.
+ * Returns locale-aware formatters backed by the native `Intl.*` APIs,
+ * built by `@intlayer/use-intl`'s `createFormatter`.
  */
 declare const getFormatter: typeof getFormatter$1;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","names":[],"sources":["../../../src/server/helpers.ts"],"mappings":";;;;;AAYA;;cAAa,YAAA,SAAqB,cAAA;;;AAWlC;;cAAa,MAAA,SAAe,QAAA;;;AAO5B;;cAAa,WAAA,SAAoB,aAAA"}
+{"version":3,"file":"helpers.d.ts","names":[],"sources":["../../../src/server/helpers.ts"],"mappings":";;;;;AAaA;;;cAAa,YAAA,SAAqB,cAAA;;AAWlC;;;cAAa,MAAA,SAAe,QAAA;;AAO5B;;;cAAa,WAAA,SAAoB,aAAA"}

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

@@ -2,7 +2,9 @@ import { getDictionary } from "../getDictionary.js";
 import { getDictionaryDynamic } from "../getDictionaryDynamic.js";
 import { getLocale } from "./getLocale.js";
 import { getMessages } from "./getMessages.js";
+import getRequestConfig from "./getRequestConfig.js";
 import { getTranslations } from "./getTranslations.js";
 import { getFormatter, getNow, getTimeZone } from "./helpers.js";
 import { setLocale } from "./setLocale.js";
-export { getDictionary, getDictionaryDynamic, getFormatter, getLocale, getMessages, getNow, getTimeZone, getTranslations, setLocale };
+import { setRequestLocale } from "./setRequestLocale.js";
+export { getDictionary, getDictionaryDynamic, getFormatter, getLocale, getMessages, getNow, getRequestConfig, getTimeZone, getTranslations, setLocale, setRequestLocale };

package/dist/types/server/requestLocaleCache.d.ts

@@ -0,0 +1,17 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/server/requestLocaleCache.d.ts
+/**
+ * Read the locale stored for the current request, or `undefined` when
+ * `setRequestLocale` has not been called.
+ */
+declare const getCachedRequestLocale: () => LocalesValues | undefined;
+/**
+ * Store the locale for the current request. Called by `setRequestLocale`.
+ *
+ * @param locale - The locale resolved from the `[locale]` route segment.
+ */
+declare const setCachedRequestLocale: (locale: LocalesValues) => void;
+//#endregion
+export { getCachedRequestLocale, setCachedRequestLocale };
+//# sourceMappingURL=requestLocaleCache.d.ts.map

package/dist/types/server/requestLocaleCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestLocaleCache.d.ts","names":[],"sources":["../../../src/server/requestLocaleCache.ts"],"mappings":";;;;;AAuBA;;cAAa,sBAAA,QAA6B,aAAA;;;AAQ1C;;;cAAa,sBAAA,GAA0B,MAAA,EAAQ,aAAA"}

package/dist/types/server/setRequestLocale.d.ts

@@ -0,0 +1,29 @@
+import { setRequestLocale as setRequestLocale$1 } from "next-intl/server";
+
+//#region src/server/setRequestLocale.d.ts
+/**
+ * Drop-in for next-intl's `setRequestLocale`.
+ *
+ * In next-intl this stores the locale (typically the `[locale]` route segment)
+ * in a request-scoped cache so the rest of the request can render in that
+ * locale and opt into static rendering. The compat keeps the same contract:
+ * the locale is stored per-request and read back by `getLocale()` (and, through
+ * it, `getTranslations` / `getDictionary` / metadata). This is what makes the
+ * per-request locale — and therefore the locale switcher — work without relying
+ * on a cookie.
+ *
+ * @param locale - The locale resolved from the `[locale]` route segment.
+ *
+ * @example
+ * ```ts
+ * export default async function LocaleLayout({ params }) {
+ *   const { locale } = await params;
+ *   setRequestLocale(locale);
+ *   // …
+ * }
+ * ```
+ */
+declare const setRequestLocale: typeof setRequestLocale$1;
+//#endregion
+export { setRequestLocale };
+//# sourceMappingURL=setRequestLocale.d.ts.map

package/dist/types/server/setRequestLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setRequestLocale.d.ts","names":[],"sources":["../../../src/server/setRequestLocale.ts"],"mappings":";;;;;AA0BA;;;;;;;;;;;;;;;;;;;;cAAa,gBAAA,SAAyB,kBAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/next-intl",
-  "version": "9.0.0-canary.2",
+  "version": "9.0.0-canary.4",
   "private": false,
   "description": "next-intl API adapter for intlayer — useTranslations, useLocale, getTranslations, getLocale, NextIntlClientProvider backed by next-intlayer",
   "keywords": [
@@ -36,37 +36,31 @@
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
-      "require": "./dist/cjs/index.cjs",
       "import": "./dist/esm/index.mjs"
     },
     "./server": {
       "types": "./dist/types/server/index.d.ts",
-      "require": "./dist/cjs/server/index.cjs",
       "import": "./dist/esm/server/index.mjs"
     },
     "./routing": {
       "types": "./dist/types/routing.d.ts",
-      "require": "./dist/cjs/routing.cjs",
       "import": "./dist/esm/routing.mjs"
     },
     "./navigation": {
       "types": "./dist/types/navigation/index.d.ts",
-      "require": "./dist/cjs/navigation/index.cjs",
       "import": "./dist/esm/navigation/index.mjs"
     },
     "./middleware": {
       "types": "./dist/types/middleware.d.ts",
-      "require": "./dist/cjs/middleware.cjs",
       "import": "./dist/esm/middleware.mjs"
     },
     "./plugin": {
       "types": "./dist/types/plugin/index.d.ts",
-      "require": "./dist/cjs/plugin/index.cjs",
       "import": "./dist/esm/plugin/index.mjs"
     },
     "./package.json": "./package.json"
   },
-  "main": "dist/cjs/index.cjs",
+  "main": "dist/esm/index.mjs",
   "module": "dist/esm/index.mjs",
   "types": "dist/types/index.d.ts",
   "typesVersions": {
@@ -110,16 +104,17 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/chokidar": "9.0.0-canary.2",
-    "@intlayer/config": "9.0.0-canary.2",
-    "@intlayer/core": "9.0.0-canary.2",
-    "@intlayer/dictionaries-entry": "9.0.0-canary.2",
-    "@intlayer/types": "9.0.0-canary.2",
-    "next-intlayer": "9.0.0-canary.2",
-    "react-intlayer": "9.0.0-canary.2"
+    "@intlayer/chokidar": "9.0.0-canary.4",
+    "@intlayer/config": "9.0.0-canary.4",
+    "@intlayer/core": "9.0.0-canary.4",
+    "@intlayer/dictionaries-entry": "9.0.0-canary.4",
+    "@intlayer/types": "9.0.0-canary.4",
+    "@intlayer/use-intl": "9.0.0-canary.4",
+    "next-intlayer": "9.0.0-canary.4",
+    "react-intlayer": "9.0.0-canary.4"
   },
   "devDependencies": {
-    "@types/node": "25.9.3",
+    "@types/node": "25.9.4",
     "@types/react": "19.2.17",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",

package/dist/cjs/client/helpers.cjs

@@ -1,66 +0,0 @@
-'use client';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-const require_createFormatter = require('../createFormatter.cjs');
-let _intlayer_config_built = require("@intlayer/config/built");
-let next_intlayer = require("next-intlayer");
-let react_jsx_runtime = require("react/jsx-runtime");
-let _intlayer_config_colors = require("@intlayer/config/colors");
-let _intlayer_config_logger = require("@intlayer/config/logger");
-
-//#region src/client/helpers.tsx
-/**
-* Drop-in for next-intl's `useNow`.
-* Returns the current `Date`. The `updateInterval` option is ignored.
-*/
-const useNow = () => /* @__PURE__ */ new Date();
-/**
-* Drop-in for next-intl's `useTimeZone`.
-* Returns the system time zone resolved from `Intl.DateTimeFormat`.
-*/
-const useTimeZone = () => Intl.DateTimeFormat().resolvedOptions().timeZone;
-/**
-* 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.
-*/
-const useMessages = () => {
-	if (process.env.NODE_ENV === "development") (0, _intlayer_config_logger.getAppLogger)({ log: _intlayer_config_built.log })(`${(0, _intlayer_config_logger.colorize)("useMessages", _intlayer_config_colors.CYAN)} has no use case with intlayer. Messages are loaded automatically under the hood for bundle optimization reason`);
-	return {};
-};
-/**
-* Drop-in for next-intl's `useFormatter`.
-* Returns locale-aware formatters backed by the native `Intl.*` APIs:
-* `dateTime`, `number`, `dateTimeRange`, `relativeTime`, `list`, and
-* `displayName`.
-*/
-const useFormatter = () => {
-	const { locale } = (0, next_intlayer.useLocale)();
-	return require_createFormatter.createFormatter(locale ?? "en");
-};
-/**
-* 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.
-*/
-const IntlProvider = ({ children }) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children });
-/**
-* @internal Not part of the public next-intl API surface; provided for
-* internal compatibility shims only.
-*/
-const useExtracted = (..._args) => ({});
-
-//#endregion
-exports.IntlProvider = IntlProvider;
-exports.useExtracted = useExtracted;
-exports.useFormatter = useFormatter;
-exports.useMessages = useMessages;
-exports.useNow = useNow;
-exports.useTimeZone = useTimeZone;
-//# sourceMappingURL=helpers.cjs.map

package/dist/cjs/client/helpers.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.cjs","names":["CYAN","createFormatter"],"sources":["../../../src/client/helpers.tsx"],"sourcesContent":["'use client';\n\nimport { log } from '@intlayer/config/built';\nimport { CYAN } from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport type {\n  IntlProvider as _IntlProvider,\n  useFormatter as _useFormatter,\n  useMessages as _useMessages,\n  useNow as _useNow,\n  useTimeZone as _useTimeZone,\n} from 'next-intl';\nimport { useLocale } from 'next-intlayer';\nimport type * as React from 'react';\nimport { createFormatter } from '../createFormatter';\n\n/**\n * Drop-in for next-intl's `useNow`.\n * Returns the current `Date`. The `updateInterval` option is ignored.\n */\nexport const useNow: typeof _useNow = () => new Date();\n\n/**\n * Drop-in for next-intl's `useTimeZone`.\n * Returns the system time zone resolved from `Intl.DateTimeFormat`.\n */\nexport const useTimeZone: typeof _useTimeZone = () =>\n  Intl.DateTimeFormat().resolvedOptions().timeZone;\n\n/**\n * Drop-in for next-intl's `useMessages`.\n *\n * @deprecated useMessages has no use case with intlayer.\n * Messages are loaded automatically under the hood.\n * @returns An empty object.\n */\nexport const useMessages: typeof _useMessages = () => {\n  if (process.env.NODE_ENV === 'development') {\n    const appLogger = getAppLogger({ log });\n    appLogger(\n      `${colorize('useMessages', CYAN)} has no use case with intlayer. Messages are loaded automatically under the hood for bundle optimization reason`\n    );\n  }\n\n  return {} as ReturnType<typeof _useMessages>;\n};\n\n/**\n * Drop-in for next-intl's `useFormatter`.\n * Returns locale-aware formatters backed by the native `Intl.*` APIs:\n * `dateTime`, `number`, `dateTimeRange`, `relativeTime`, `list`, and\n * `displayName`.\n */\nexport const useFormatter: typeof _useFormatter = () => {\n  const { locale } = useLocale();\n  return createFormatter((locale as string) ?? 'en');\n};\n\ninterface ProviderProps {\n  children?: React.ReactNode;\n  [key: string]: unknown;\n}\n\n/**\n * Drop-in for next-intl's `IntlProvider`.\n * Renders children as-is — Intlayer provides its own context via\n * `IntlayerClientProvider`.\n *\n * @deprecated IntlProvider has no use case with intlayer.\n * Use `IntlayerClientProvider` or `NextIntlClientProvider` instead.\n */\nexport const IntlProvider: typeof _IntlProvider = ({\n  children,\n}: ProviderProps) => <>{children}</>;\n\n/**\n * @internal Not part of the public next-intl API surface; provided for\n * internal compatibility shims only.\n */\nexport const useExtracted = (..._args: unknown[]) => ({});\n"],"mappings":";;;;;;;;;;;;;;;;AAoBA,MAAa,+BAA+B,IAAI,MAAM;;;;;AAMtD,MAAa,oBACX,KAAK,gBAAgB,CAAC,iBAAiB,CAAC;;;;;;;;AAS1C,MAAa,oBAAyC;AACpD,KAAI,QAAQ,IAAI,aAAa,cAE3B,2CAD+B,EAAE,iCAAK,CAC7B,CACP,yCAAY,eAAeA,6BAAK,CAAC,iHAClC;AAGH,QAAO,EAAE;;;;;;;;AASX,MAAa,qBAA2C;CACtD,MAAM,EAAE,yCAAsB;AAC9B,QAAOC,wCAAiB,UAAqB,KAAK;;;;;;;;;;AAgBpD,MAAa,gBAAsC,EACjD,eACmB,yEAAG,UAAY;;;;;AAMpC,MAAa,gBAAgB,GAAG,WAAsB,EAAE"}