@intlayer/next-intl 9.4.3 → 9.5.0

package/README.md

@@ -69,8 +69,6 @@ With **per-locale content files**, **TypeScript autocompletion**, **tree-shakabl
 | <img src="https://github.com/aymericzip/intlayer/blob/main/docs/assets/interoperability.png?raw=true" alt="Feature" width="700">                    | **Interoperability**<br><br>Allow interoperability with react-i18next, next-i18next, next-intl, react-intl, vue-i18n. <br><br> - [Intlayer and react-intl](https://intlayer.org/blog/intlayer-with-react-intl) <br> - [Intlayer and next-intl](https://intlayer.org/blog/intlayer-with-next-intl) <br> - [Intlayer and next-i18next](https://intlayer.org/blog/intlayer-with-next-i18next) <br> - [Intlayer and vue-i18n](https://intlayer.org/blog/intlayer-with-vue-i18n) <br> - [Intlayer compat adapters](https://intlayer.org/doc/compatibility) |
 | <img src="https://github.com/aymericzip/intlayer/blob/main/docs/assets/benchmark.png?raw=true" alt="Feature" width="700">                           | **Performances & Benchmark**<br><br>Uses advanced tree-shaking and dynamic loading to boost performances and keep the solution as light as possible. <br><br> - [Performances & Benchmark](https://intlayer.org/doc/benchmark)                                                                                                                                                                                                                                                                                                                        |
 
----
-
 ## 📦 Installation
 
 Start your journey with Intlayer today and experience a smoother, more powerful approach to internationalization.

package/dist/cjs/plugin/index.cjs

@@ -80,6 +80,24 @@ const resolveEsmPath = (specifier) => {
 	return (0, node_path.resolve)(packageDir, relativeFile);
 };
 /**
+* Absolute path of a specifier's `react-server` export condition, when the
+* package declares one.
+*
+* Aliasing to a file bypasses the package's `exports` map, so the condition
+* would never be consulted — the alias itself has to carry it. Without this,
+* every Server Component resolves the client build of `useTranslations`, gets
+* pulled across the client boundary, and drags its dictionary into a chunk
+* Next shares across every locale.
+*/
+const resolveReactServerPath = (specifier) => {
+	const { packageName, exportKey } = splitSpecifier(specifier);
+	const packageJson = compatRequire(`${packageName}/package.json`);
+	const packageDir = (0, node_path.dirname)(compatRequire.resolve(`${packageName}/package.json`));
+	const exportEntry = packageJson.exports?.[exportKey];
+	const relativeFile = typeof exportEntry === "string" ? void 0 : exportEntry?.["react-server"];
+	return relativeFile ? (0, node_path.resolve)(packageDir, relativeFile) : void 0;
+};
+/**
 * Format an absolute path as a project-root-relative specifier (prefixed with
 * `./` and using forward slashes). Turbopack only honours `resolveAlias` values
 * that are project-root-relative paths — bare specifiers are ignored and
@@ -91,12 +109,6 @@ const resolveEsmPath = (specifier) => {
 */
 const toTurbopackAlias = (absolutePath) => `./${(0, node_path.relative)(process.cwd(), absolutePath).split(node_path.sep).join("/")}`;
 /**
-* SWC extra-caller configs derived from the shared caller registry
-* (`@intlayer/config/callers`) — the single source of truth also consumed by
-* the babel analyzer/optimizer and the LSP.
-*/
-const NEXT_INTL_SWC_CALLERS = (0, _intlayer_config_callers.toSwcExtraCallers)(_intlayer_config_callers.NEXT_INTL_CALLERS);
-/**
 * A Next.js plugin for next-intl compat that wraps next-intlayer's plugin
 * and configures resolve aliases so `next-intl` imports are served by
 * `@intlayer/next-intl`.
@@ -111,10 +123,23 @@ const createNextIntlPlugin = (_i18nPath) => {
 		const customWebpack = nextConfig.webpack;
 		const resolvedTargets = ALIAS_ENTRIES.map(({ request, replacement }) => ({
 			request,
-			absolutePath: resolveEsmPath(replacement)
+			replacement,
+			hasReactServerBuild: Boolean(resolveReactServerPath(replacement))
 		}));
-		const webpackAlias = Object.fromEntries(resolvedTargets.map(({ request, absolutePath }) => [request, absolutePath]));
-		const turboAlias = Object.fromEntries(resolvedTargets.map(({ request, absolutePath }) => [request, toTurbopackAlias(absolutePath)]));
+		/**
+		* Aliasing to a resolved *file* pins one build of the target and bypasses
+		* its `exports` map — so the `react-server` condition is never consulted
+		* and a Server Component silently gets the client build of
+		* `useTranslations`. That drags every component calling it across the
+		* client boundary, and with it the multi-locale dictionary, into a chunk
+		* Next serves to every locale.
+		*
+		* Aliasing to the package specifier instead lets the bundler resolve
+		* normally, so each layer picks its own condition.
+		*/
+		const aliasTarget = ({ replacement, hasReactServerBuild }) => hasReactServerBuild ? replacement : toTurbopackAlias(resolveEsmPath(replacement));
+		const webpackAlias = Object.fromEntries(resolvedTargets.map(({ request, replacement, hasReactServerBuild }) => [request, hasReactServerBuild ? replacement : resolveEsmPath(replacement)]));
+		const turboAlias = Object.fromEntries(resolvedTargets.map((target) => [target.request, aliasTarget(target)]));
 		const aliasConfig = { webpack: (config, options) => {
 			config.resolve.alias = {
 				...config.resolve.alias,
@@ -138,7 +163,7 @@ const createNextIntlPlugin = (_i18nPath) => {
 		try {
 			hasUserDefinedStorage = !!(intlayerConfig?.routing && "storage" in intlayerConfig.routing && intlayerConfig.routing.storage !== void 0);
 		} catch {}
-		return (0, next_intlayer_server.withIntlayer)(mergedConfig, hasUserDefinedStorage ? { swcExtraCallers: NEXT_INTL_SWC_CALLERS } : {
+		return (0, next_intlayer_server.withIntlayer)(mergedConfig, hasUserDefinedStorage ? { compatCallers: _intlayer_config_callers.NEXT_INTL_CALLERS } : {
 			override: { routing: { storage: [{
 				type: "cookie",
 				name: "NEXT_LOCALE"
@@ -146,7 +171,7 @@ const createNextIntlPlugin = (_i18nPath) => {
 				type: "header",
 				name: "x-intlayer-locale"
 			}] } },
-			swcExtraCallers: NEXT_INTL_SWC_CALLERS
+			compatCallers: _intlayer_config_callers.NEXT_INTL_CALLERS
 		});
 	};
 };

package/dist/cjs/plugin/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["createRequire","dirname","resolve","relative","sep","toSwcExtraCallers","NEXT_INTL_CALLERS","getConfiguration","getAppLogger","join","colorize","ANSIColors","withIntlayer"],"sources":["../../../src/plugin/index.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport { dirname, join, relative, resolve, sep } from 'node:path';\nimport { NEXT_INTL_CALLERS, toSwcExtraCallers } from '@intlayer/config/callers';\nimport * as ANSIColors from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport { getConfiguration } from '@intlayer/config/node';\nimport { runOnce } from '@intlayer/engine/utils';\nimport type { NextConfig } from 'next';\nimport { withIntlayer } from 'next-intlayer/server';\n\n/**\n * `require` that works in both the CJS and ESM builds of this plugin.\n * `import.meta.url` is rewritten to the module path in the CJS output by the\n * bundler, so `createRequire` resolves correctly in either format.\n */\nconst compatRequire = createRequire(import.meta.url);\n\n/**\n * Maps each original `next-intl` import specifier to the `@intlayer/next-intl`\n * specifier that should serve it instead.\n */\nconst ALIAS_ENTRIES: { request: string; replacement: string }[] = [\n  { request: 'next-intl/server', replacement: '@intlayer/next-intl/server' },\n  { request: 'next-intl/routing', replacement: '@intlayer/next-intl/routing' },\n  {\n    request: 'next-intl/navigation',\n    replacement: '@intlayer/next-intl/navigation',\n  },\n  {\n    request: 'next-intl/middleware',\n    replacement: '@intlayer/next-intl/middleware',\n  },\n  { request: 'next-intl', replacement: '@intlayer/next-intl' },\n];\n\n/**\n * Split a package specifier into its package name and export subpath.\n *\n * @param specifier - e.g. `@intlayer/next-intl/server` or `next-intl`.\n * @returns `{ packageName, exportKey }` where `exportKey` is the `exports` map\n * key (`.` for the package root).\n */\nconst splitSpecifier = (\n  specifier: string\n): { packageName: string; exportKey: string } => {\n  const segments = specifier.split('/');\n  const packageName = specifier.startsWith('@')\n    ? segments.slice(0, 2).join('/')\n    : (segments[0] ?? specifier);\n  const subpath = specifier.slice(packageName?.length);\n  return { packageName, exportKey: subpath === '' ? '.' : `.${subpath}` };\n};\n\n/**\n * Resolve the absolute path of a package export, preferring the ESM (`import`)\n * condition so Turbopack and modern bundlers load the `.mjs` build (which keeps\n * the `\"use client\"` directives) rather than the CommonJS fallback.\n *\n * Both Turbopack and webpack ignore alias values that are bare package\n * specifiers, so the aliases must point at real files.\n *\n * @param specifier - Package specifier, e.g. `@intlayer/next-intl/server`.\n * @returns Absolute path to the resolved module file.\n */\nconst resolveEsmPath = (specifier: string): string => {\n  const { packageName, exportKey } = splitSpecifier(specifier);\n  const packageJson = compatRequire(`${packageName}/package.json`) as {\n    exports?: Record<\n      string,\n      string | { import?: string; require?: string; default?: string }\n    >;\n  };\n  const packageDir = dirname(\n    compatRequire.resolve(`${packageName}/package.json`)\n  );\n\n  const exportEntry = packageJson.exports?.[exportKey];\n  const relativeFile =\n    typeof exportEntry === 'string'\n      ? exportEntry\n      : (exportEntry?.import ?? exportEntry?.require ?? exportEntry?.default);\n\n  // Fall back to Node resolution if the exports map is unexpected.\n  if (!relativeFile) return compatRequire.resolve(specifier);\n\n  return resolve(packageDir, relativeFile);\n};\n\n/**\n * Format an absolute path as a project-root-relative specifier (prefixed with\n * `./` and using forward slashes). Turbopack only honours `resolveAlias` values\n * that are project-root-relative paths — bare specifiers are ignored and\n * absolute paths are misread as root-relative. Mirrors `withIntlayer`'s\n * Turbopack alias formatter.\n *\n * @param absolutePath - Absolute path to the target module file.\n * @returns Relative specifier such as `./node_modules/@intlayer/next-intl/...`.\n */\nconst toTurbopackAlias = (absolutePath: string): string =>\n  `./${relative(process.cwd(), absolutePath).split(sep).join('/')}`;\n\n/**\n * SWC extra-caller configs derived from the shared caller registry\n * (`@intlayer/config/callers`) — the single source of truth also consumed by\n * the babel analyzer/optimizer and the LSP.\n */\nconst NEXT_INTL_SWC_CALLERS = toSwcExtraCallers(NEXT_INTL_CALLERS);\n\n/**\n * A Next.js plugin for next-intl compat that wraps next-intlayer's plugin\n * and configures resolve aliases so `next-intl` imports are served by\n * `@intlayer/next-intl`.\n */\nexport const createNextIntlPlugin = (_i18nPath?: string) => {\n  return async (nextConfig: NextConfig = {}): Promise<NextConfig> => {\n    const intlayerConfig = getConfiguration();\n    const appLogger = getAppLogger(intlayerConfig);\n\n    runOnce(\n      join(\n        intlayerConfig?.system?.baseDir ?? process.cwd(),\n        '.intlayer',\n        'cache',\n        'intlayer-issues-invitation.lock'\n      ),\n      () => {\n        appLogger([\n          colorize(\n            'Please report any issues you met on GitHub:',\n            ANSIColors.GREY\n          ),\n          colorize(\n            'https://github.com/aymericzip/intlayer/issues',\n            ANSIColors.GREY_LIGHT\n          ),\n        ]);\n      },\n      {\n        cacheTimeoutMs: 1000 * 60 * 60, // 1 hour\n      }\n    );\n\n    const customWebpack = nextConfig.webpack;\n\n    const resolvedTargets = ALIAS_ENTRIES.map(({ request, replacement }) => ({\n      request,\n      absolutePath: resolveEsmPath(replacement),\n    }));\n\n    // Webpack resolves aliases from absolute paths.\n    const webpackAlias = Object.fromEntries(\n      resolvedTargets.map(({ request, absolutePath }) => [\n        request,\n        absolutePath,\n      ])\n    );\n\n    // Turbopack only honours project-root-relative `./` paths.\n    const turboAlias = Object.fromEntries(\n      resolvedTargets.map(({ request, absolutePath }) => [\n        request,\n        toTurbopackAlias(absolutePath),\n      ])\n    );\n\n    const aliasConfig = {\n      webpack: (config: any, options: any) => {\n        config.resolve.alias = {\n          ...config.resolve.alias,\n          ...webpackAlias,\n        };\n\n        if (typeof customWebpack === 'function') {\n          return customWebpack(config, options);\n        }\n        return config;\n      },\n    };\n\n    const mergedConfig: NextConfig = {\n      ...nextConfig,\n      ...aliasConfig,\n      turbopack: {\n        ...(nextConfig.turbopack ?? {}),\n        resolveAlias: {\n          ...(nextConfig.turbopack?.resolveAlias ?? {}),\n          ...turboAlias,\n        },\n      },\n    };\n\n    // Only inject the NEXT_LOCALE cookie default when the user has not\n    // configured their own routing.storage in intlayer.config.ts.\n    // This lets users override via intlayer.config.ts while keeping\n    // next-intl compatibility (NEXT_LOCALE) as the default.\n    let hasUserDefinedStorage = false;\n    try {\n      hasUserDefinedStorage = !!(\n        intlayerConfig?.routing &&\n        'storage' in intlayerConfig.routing &&\n        intlayerConfig.routing.storage !== undefined\n      );\n    } catch {\n      // If the config file cannot be read, fall back to the NEXT_LOCALE default.\n    }\n\n    const configOptions = hasUserDefinedStorage\n      ? { swcExtraCallers: NEXT_INTL_SWC_CALLERS }\n      : {\n          override: {\n            routing: {\n              storage: [\n                { type: 'cookie' as const, name: 'NEXT_LOCALE' },\n                { type: 'header' as const, name: 'x-intlayer-locale' },\n              ],\n            },\n          },\n          swcExtraCallers: NEXT_INTL_SWC_CALLERS,\n        };\n\n    return withIntlayer(mergedConfig, configOptions);\n  };\n};\n\nexport default createNextIntlPlugin;\n"],"mappings":"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"}
+{"version":3,"file":"index.cjs","names":["createRequire","dirname","resolve","relative","sep","getConfiguration","getAppLogger","join","colorize","ANSIColors","withIntlayer","NEXT_INTL_CALLERS"],"sources":["../../../src/plugin/index.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport { dirname, join, relative, resolve, sep } from 'node:path';\nimport { NEXT_INTL_CALLERS } from '@intlayer/config/callers';\nimport * as ANSIColors from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport { getConfiguration } from '@intlayer/config/node';\nimport { runOnce } from '@intlayer/engine/utils';\nimport type { NextConfig } from 'next';\nimport { withIntlayer } from 'next-intlayer/server';\n\n/**\n * `require` that works in both the CJS and ESM builds of this plugin.\n * `import.meta.url` is rewritten to the module path in the CJS output by the\n * bundler, so `createRequire` resolves correctly in either format.\n */\nconst compatRequire = createRequire(import.meta.url);\n\n/**\n * Maps each original `next-intl` import specifier to the `@intlayer/next-intl`\n * specifier that should serve it instead.\n */\nconst ALIAS_ENTRIES: { request: string; replacement: string }[] = [\n  { request: 'next-intl/server', replacement: '@intlayer/next-intl/server' },\n  { request: 'next-intl/routing', replacement: '@intlayer/next-intl/routing' },\n  {\n    request: 'next-intl/navigation',\n    replacement: '@intlayer/next-intl/navigation',\n  },\n  {\n    request: 'next-intl/middleware',\n    replacement: '@intlayer/next-intl/middleware',\n  },\n  { request: 'next-intl', replacement: '@intlayer/next-intl' },\n];\n\n/**\n * Split a package specifier into its package name and export subpath.\n *\n * @param specifier - e.g. `@intlayer/next-intl/server` or `next-intl`.\n * @returns `{ packageName, exportKey }` where `exportKey` is the `exports` map\n * key (`.` for the package root).\n */\nconst splitSpecifier = (\n  specifier: string\n): { packageName: string; exportKey: string } => {\n  const segments = specifier.split('/');\n  const packageName = specifier.startsWith('@')\n    ? segments.slice(0, 2).join('/')\n    : (segments[0] ?? specifier);\n  const subpath = specifier.slice(packageName?.length);\n  return { packageName, exportKey: subpath === '' ? '.' : `.${subpath}` };\n};\n\n/**\n * Resolve the absolute path of a package export, preferring the ESM (`import`)\n * condition so Turbopack and modern bundlers load the `.mjs` build (which keeps\n * the `\"use client\"` directives) rather than the CommonJS fallback.\n *\n * Both Turbopack and webpack ignore alias values that are bare package\n * specifiers, so the aliases must point at real files.\n *\n * @param specifier - Package specifier, e.g. `@intlayer/next-intl/server`.\n * @returns Absolute path to the resolved module file.\n */\nconst resolveEsmPath = (specifier: string): string => {\n  const { packageName, exportKey } = splitSpecifier(specifier);\n  const packageJson = compatRequire(`${packageName}/package.json`) as {\n    exports?: Record<\n      string,\n      | string\n      | {\n          'react-server'?: string;\n          import?: string;\n          require?: string;\n          default?: string;\n        }\n    >;\n  };\n  const packageDir = dirname(\n    compatRequire.resolve(`${packageName}/package.json`)\n  );\n\n  const exportEntry = packageJson.exports?.[exportKey];\n  const relativeFile =\n    typeof exportEntry === 'string'\n      ? exportEntry\n      : (exportEntry?.import ?? exportEntry?.require ?? exportEntry?.default);\n\n  // Fall back to Node resolution if the exports map is unexpected.\n  if (!relativeFile) return compatRequire.resolve(specifier);\n\n  return resolve(packageDir, relativeFile);\n};\n\n/**\n * Absolute path of a specifier's `react-server` export condition, when the\n * package declares one.\n *\n * Aliasing to a file bypasses the package's `exports` map, so the condition\n * would never be consulted — the alias itself has to carry it. Without this,\n * every Server Component resolves the client build of `useTranslations`, gets\n * pulled across the client boundary, and drags its dictionary into a chunk\n * Next shares across every locale.\n */\nconst resolveReactServerPath = (specifier: string): string | undefined => {\n  const { packageName, exportKey } = splitSpecifier(specifier);\n  const packageJson = compatRequire(`${packageName}/package.json`) as {\n    exports?: Record<string, string | { 'react-server'?: string }>;\n  };\n  const packageDir = dirname(\n    compatRequire.resolve(`${packageName}/package.json`)\n  );\n\n  const exportEntry = packageJson.exports?.[exportKey];\n  const relativeFile =\n    typeof exportEntry === 'string' ? undefined : exportEntry?.['react-server'];\n\n  return relativeFile ? resolve(packageDir, relativeFile) : undefined;\n};\n\n/**\n * Format an absolute path as a project-root-relative specifier (prefixed with\n * `./` and using forward slashes). Turbopack only honours `resolveAlias` values\n * that are project-root-relative paths — bare specifiers are ignored and\n * absolute paths are misread as root-relative. Mirrors `withIntlayer`'s\n * Turbopack alias formatter.\n *\n * @param absolutePath - Absolute path to the target module file.\n * @returns Relative specifier such as `./node_modules/@intlayer/next-intl/...`.\n */\nconst toTurbopackAlias = (absolutePath: string): string =>\n  `./${relative(process.cwd(), absolutePath).split(sep).join('/')}`;\n\n/**\n * A Next.js plugin for next-intl compat that wraps next-intlayer's plugin\n * and configures resolve aliases so `next-intl` imports are served by\n * `@intlayer/next-intl`.\n */\nexport const createNextIntlPlugin = (_i18nPath?: string) => {\n  return async (nextConfig: NextConfig = {}): Promise<NextConfig> => {\n    const intlayerConfig = getConfiguration();\n    const appLogger = getAppLogger(intlayerConfig);\n\n    runOnce(\n      join(\n        intlayerConfig?.system?.baseDir ?? process.cwd(),\n        '.intlayer',\n        'cache',\n        'intlayer-issues-invitation.lock'\n      ),\n      () => {\n        appLogger([\n          colorize(\n            'Please report any issues you met on GitHub:',\n            ANSIColors.GREY\n          ),\n          colorize(\n            'https://github.com/aymericzip/intlayer/issues',\n            ANSIColors.GREY_LIGHT\n          ),\n        ]);\n      },\n      {\n        cacheTimeoutMs: 1000 * 60 * 60, // 1 hour\n      }\n    );\n\n    const customWebpack = nextConfig.webpack;\n\n    const resolvedTargets = ALIAS_ENTRIES.map(({ request, replacement }) => ({\n      request,\n      replacement,\n      hasReactServerBuild: Boolean(resolveReactServerPath(replacement)),\n    }));\n\n    /**\n     * Aliasing to a resolved *file* pins one build of the target and bypasses\n     * its `exports` map — so the `react-server` condition is never consulted\n     * and a Server Component silently gets the client build of\n     * `useTranslations`. That drags every component calling it across the\n     * client boundary, and with it the multi-locale dictionary, into a chunk\n     * Next serves to every locale.\n     *\n     * Aliasing to the package specifier instead lets the bundler resolve\n     * normally, so each layer picks its own condition.\n     */\n    const aliasTarget = ({\n      replacement,\n      hasReactServerBuild,\n    }: {\n      replacement: string;\n      hasReactServerBuild: boolean;\n    }) =>\n      hasReactServerBuild\n        ? replacement\n        : toTurbopackAlias(resolveEsmPath(replacement));\n\n    const webpackAlias = Object.fromEntries(\n      resolvedTargets.map(({ request, replacement, hasReactServerBuild }) => [\n        request,\n        hasReactServerBuild ? replacement : resolveEsmPath(replacement),\n      ])\n    );\n\n    const turboAlias = Object.fromEntries(\n      resolvedTargets.map((target) => [target.request, aliasTarget(target)])\n    );\n\n    const aliasConfig = {\n      webpack: (config: any, options: any) => {\n        config.resolve.alias = {\n          ...config.resolve.alias,\n          ...webpackAlias,\n        };\n\n        if (typeof customWebpack === 'function') {\n          return customWebpack(config, options);\n        }\n        return config;\n      },\n    };\n\n    const mergedConfig: NextConfig = {\n      ...nextConfig,\n      ...aliasConfig,\n      turbopack: {\n        ...(nextConfig.turbopack ?? {}),\n        resolveAlias: {\n          ...(nextConfig.turbopack?.resolveAlias ?? {}),\n          ...turboAlias,\n        },\n      },\n    };\n\n    // Only inject the NEXT_LOCALE cookie default when the user has not\n    // configured their own routing.storage in intlayer.config.ts.\n    // This lets users override via intlayer.config.ts while keeping\n    // next-intl compatibility (NEXT_LOCALE) as the default.\n    let hasUserDefinedStorage = false;\n    try {\n      hasUserDefinedStorage = !!(\n        intlayerConfig?.routing &&\n        'storage' in intlayerConfig.routing &&\n        intlayerConfig.routing.storage !== undefined\n      );\n    } catch {\n      // If the config file cannot be read, fall back to the NEXT_LOCALE default.\n    }\n\n    const configOptions = hasUserDefinedStorage\n      ? { compatCallers: NEXT_INTL_CALLERS }\n      : {\n          override: {\n            routing: {\n              storage: [\n                { type: 'cookie' as const, name: 'NEXT_LOCALE' },\n                { type: 'header' as const, name: 'x-intlayer-locale' },\n              ],\n            },\n          },\n          compatCallers: NEXT_INTL_CALLERS,\n        };\n\n    return withIntlayer(mergedConfig, configOptions);\n  };\n};\n\nexport default createNextIntlPlugin;\n"],"mappings":"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"}

package/dist/cjs/react-server/helpers.cjs

@@ -0,0 +1,20 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_react_server_useLocale = require('./useLocale.cjs');
+let _intlayer_use_intl = require("@intlayer/use-intl");
+
+//#region src/react-server/helpers.ts
+/**
+* Server counterparts of use-intl's ambient hooks. They mirror the client
+* versions' signatures so the same component code type-checks on both sides.
+*/
+const useFormatter = (() => (0, _intlayer_use_intl.createFormatter)({ locale: require_react_server_useLocale.useLocale() }));
+/** Current time on the server render. */
+const useNow = (() => /* @__PURE__ */ new Date());
+/** Time zone used by the formatters; UTC unless the app overrides it. */
+const useTimeZone = (() => void 0);
+
+//#endregion
+exports.useFormatter = useFormatter;
+exports.useNow = useNow;
+exports.useTimeZone = useTimeZone;
+//# sourceMappingURL=helpers.cjs.map

package/dist/cjs/react-server/helpers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.cjs","names":["createFormatter","useLocale"],"sources":["../../../src/react-server/helpers.ts"],"sourcesContent":["import { createFormatter } from '@intlayer/use-intl';\nimport { useLocale } from './useLocale';\n\n/**\n * Server counterparts of use-intl's ambient hooks. They mirror the client\n * versions' signatures so the same component code type-checks on both sides.\n */\nexport const useFormatter: typeof import('@intlayer/use-intl').useFormatter =\n  (() => createFormatter({ locale: useLocale() as string })) as never;\n\n/** Current time on the server render. */\nexport const useNow: typeof import('@intlayer/use-intl').useNow = (() =>\n  new Date()) as never;\n\n/** Time zone used by the formatters; UTC unless the app overrides it. */\nexport const useTimeZone: typeof import('@intlayer/use-intl').useTimeZone =\n  (() => undefined) as never;\n"],"mappings":";;;;;;;;;AAOA,MAAa,0BACJA,oCAAgB,EAAE,QAAQC,yCAAU,EAAY,CAAC;;AAG1D,MAAa,gCACX,IAAI,KAAK;;AAGX,MAAa,qBACJ"}

package/dist/cjs/react-server/index.cjs

@@ -0,0 +1,61 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_routing = require('../routing.cjs');
+const require_client_NextIntlClientProvider = require('../client/NextIntlClientProvider.cjs');
+const require_react_server_useTranslations = require('./useTranslations.cjs');
+const require_react_server_useLocale = require('./useLocale.cjs');
+const require_react_server_helpers = require('./helpers.cjs');
+const require_react_server_useDictionaryDynamic = require('./useDictionaryDynamic.cjs');
+const require_react_server_useDictionary = require('./useDictionary.cjs');
+let _intlayer_use_intl = require("@intlayer/use-intl");
+
+Object.defineProperty(exports, 'IntlError', {
+  enumerable: true,
+  get: function () {
+    return _intlayer_use_intl.IntlError;
+  }
+});
+Object.defineProperty(exports, 'IntlErrorCode', {
+  enumerable: true,
+  get: function () {
+    return _intlayer_use_intl.IntlErrorCode;
+  }
+});
+exports.NextIntlClientProvider = require_client_NextIntlClientProvider.NextIntlClientProvider;
+Object.defineProperty(exports, 'createFormatter', {
+  enumerable: true,
+  get: function () {
+    return _intlayer_use_intl.createFormatter;
+  }
+});
+Object.defineProperty(exports, 'createTranslator', {
+  enumerable: true,
+  get: function () {
+    return _intlayer_use_intl.createTranslator;
+  }
+});
+exports.defineRouting = require_routing.defineRouting;
+Object.defineProperty(exports, 'hasLocale', {
+  enumerable: true,
+  get: function () {
+    return _intlayer_use_intl.hasLocale;
+  }
+});
+Object.defineProperty(exports, 'initializeConfig', {
+  enumerable: true,
+  get: function () {
+    return _intlayer_use_intl.initializeConfig;
+  }
+});
+exports.useDictionary = require_react_server_useDictionary.useDictionary;
+exports.useDictionaryDynamic = require_react_server_useDictionaryDynamic.useDictionaryDynamic;
+exports.useFormatter = require_react_server_helpers.useFormatter;
+exports.useLocale = require_react_server_useLocale.useLocale;
+Object.defineProperty(exports, 'useMessages', {
+  enumerable: true,
+  get: function () {
+    return _intlayer_use_intl.useMessages;
+  }
+});
+exports.useNow = require_react_server_helpers.useNow;
+exports.useTimeZone = require_react_server_helpers.useTimeZone;
+exports.useTranslations = require_react_server_useTranslations.useTranslations;

package/dist/cjs/react-server/resolveLocale.cjs

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_server_requestLocaleCache = require('../server/requestLocaleCache.cjs');
+let next_intlayer_server = require("next-intlayer/server");
+
+//#region src/react-server/resolveLocale.ts
+/**
+* Locale for a synchronous server hook, resolved the same way `getLocale()`
+* resolves it — so server-rendered content and the client provider never
+* disagree about which locale the request is in.
+*
+* 1. The locale forwarded through `setRequestLocale(locale)` (the `[locale]`
+*    route segment), which is next-intl's source of truth for URL routing.
+* 2. Otherwise Intlayer's ambient locale (server context, then the request).
+*/
+const resolveServerLocale = () => require_server_requestLocaleCache.getCachedRequestLocale() ?? (0, next_intlayer_server.useLocale)().locale;
+
+//#endregion
+exports.resolveServerLocale = resolveServerLocale;
+//# sourceMappingURL=resolveLocale.cjs.map

package/dist/cjs/react-server/resolveLocale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveLocale.cjs","names":["getCachedRequestLocale","useLocaleIntlayer"],"sources":["../../../src/react-server/resolveLocale.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { useLocale as useLocaleIntlayer } from 'next-intlayer/server';\nimport { getCachedRequestLocale } from '../server/requestLocaleCache';\n\n/**\n * Locale for a synchronous server hook, resolved the same way `getLocale()`\n * resolves it — so server-rendered content and the client provider never\n * disagree about which locale the request is in.\n *\n * 1. The locale forwarded through `setRequestLocale(locale)` (the `[locale]`\n *    route segment), which is next-intl's source of truth for URL routing.\n * 2. Otherwise Intlayer's ambient locale (server context, then the request).\n */\nexport const resolveServerLocale = (): LocalesValues =>\n  (getCachedRequestLocale() ??\n    useLocaleIntlayer().locale) as LocalesValues;\n"],"mappings":";;;;;;;;;;;;;;AAaA,MAAa,4BACVA,yDAAuB,SACtBC,gCAAkB,CAAC,CAAC"}

package/dist/cjs/react-server/useDictionary.cjs

@@ -0,0 +1,23 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_react_server_resolveLocale = require('./resolveLocale.cjs');
+let _intlayer_use_intl = require("@intlayer/use-intl");
+let next_intlayer_server = require("next-intlayer/server");
+
+//#region src/react-server/useDictionary.ts
+/**
+* Server counterpart of `@intlayer/use-intl`'s `useDictionary`.
+*
+* The optimize pass rewrites every `useTranslations(...)` call to this helper
+* with the dictionary pre-imported. Resolving it here — rather than in a client
+* component — keeps the dictionary out of the client bundle entirely: the
+* server renders the text and only the rendered output crosses the boundary.
+*/
+const useDictionary = ((dictionary, namespacePrefix) => {
+	const locale = require_react_server_resolveLocale.resolveServerLocale();
+	const content = (0, next_intlayer_server.useDictionary)(dictionary, locale);
+	return (0, _intlayer_use_intl.createDictionaryTranslator)(locale, content, namespacePrefix);
+});
+
+//#endregion
+exports.useDictionary = useDictionary;
+//# sourceMappingURL=useDictionary.cjs.map

package/dist/cjs/react-server/useDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionary.cjs","names":["resolveServerLocale","useDictionaryBase","createDictionaryTranslator"],"sources":["../../../src/react-server/useDictionary.ts"],"sourcesContent":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport {\n  createDictionaryTranslator,\n  type ScopedTranslateFunction,\n  type TranslateFunction,\n} from '@intlayer/use-intl';\nimport { useDictionary as useDictionaryBase } from 'next-intlayer/server';\nimport { resolveServerLocale } from './resolveLocale';\n\n/**\n * Overload set mirroring the client `useDictionary` exactly, so the optimize\n * pass can emit the same call shape whichever side of the boundary the\n * component ends up on.\n */\ntype UseDictionary = {\n  <T extends Dictionary>(\n    dictionary: T\n  ): TranslateFunction<T['key'] & DictionaryKeys>;\n  <T extends Dictionary, Prefix extends string>(\n    dictionary: T,\n    namespacePrefix: Prefix\n  ): ScopedTranslateFunction<T['key'] & DictionaryKeys, Prefix>;\n};\n\n/**\n * Server counterpart of `@intlayer/use-intl`'s `useDictionary`.\n *\n * The optimize pass rewrites every `useTranslations(...)` call to this helper\n * with the dictionary pre-imported. Resolving it here — rather than in a client\n * component — keeps the dictionary out of the client bundle entirely: the\n * server renders the text and only the rendered output crosses the boundary.\n */\nexport const useDictionary = (<T extends Dictionary>(\n  dictionary: T,\n  namespacePrefix?: string\n) => {\n  const locale = resolveServerLocale();\n  const content = useDictionaryBase(dictionary, locale as never);\n\n  return createDictionaryTranslator(\n    locale,\n    content,\n    namespacePrefix\n  );\n}) as UseDictionary;\n"],"mappings":";;;;;;;;;;;;;;AAoCA,MAAa,kBACX,YACA,oBACG;CACH,MAAM,SAASA,uDAAoB;CACnC,MAAM,cAAUC,oCAAkB,YAAY,MAAe;CAE7D,WAAOC,+CACL,QACA,SACA,eACF;AACF"}

package/dist/cjs/react-server/useDictionaryDynamic.cjs

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_react_server_resolveLocale = require('./resolveLocale.cjs');
+let _intlayer_use_intl = require("@intlayer/use-intl");
+let next_intlayer_server = require("next-intlayer/server");
+
+//#region src/react-server/useDictionaryDynamic.ts
+/**
+* Server counterpart of `useDictionaryDynamic`, emitted by the optimize pass
+* for dictionaries on the per-locale loader.
+*/
+const useDictionaryDynamic = ((dictionaryPromise, key, namespacePrefix) => {
+	const locale = require_react_server_resolveLocale.resolveServerLocale();
+	const content = (0, next_intlayer_server.useDictionaryDynamic)(dictionaryPromise, key, locale);
+	return (0, _intlayer_use_intl.createDictionaryTranslator)(locale, content, namespacePrefix);
+});
+
+//#endregion
+exports.useDictionaryDynamic = useDictionaryDynamic;
+//# sourceMappingURL=useDictionaryDynamic.cjs.map

package/dist/cjs/react-server/useDictionaryDynamic.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionaryDynamic.cjs","names":["resolveServerLocale","useDictionaryDynamicBase","createDictionaryTranslator"],"sources":["../../../src/react-server/useDictionaryDynamic.ts"],"sourcesContent":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport {\n  createDictionaryTranslator,\n  type ScopedTranslateFunction,\n  type TranslateFunction,\n} from '@intlayer/use-intl';\nimport { useDictionaryDynamic as useDictionaryDynamicBase } from 'next-intlayer/server';\nimport { resolveServerLocale } from './resolveLocale';\n\ntype UseDictionaryDynamic = {\n  <T extends Dictionary, K extends DictionaryKeys>(\n    dictionaryPromise: Record<string, () => Promise<T>>,\n    key: K\n  ): TranslateFunction<K>;\n  <T extends Dictionary, K extends DictionaryKeys, Prefix extends string>(\n    dictionaryPromise: Record<string, () => Promise<T>>,\n    key: K,\n    namespacePrefix: Prefix\n  ): ScopedTranslateFunction<K, Prefix>;\n};\n\n/**\n * Server counterpart of `useDictionaryDynamic`, emitted by the optimize pass\n * for dictionaries on the per-locale loader.\n */\nexport const useDictionaryDynamic = ((\n  dictionaryPromise: Record<string, () => Promise<Dictionary>>,\n  key: string,\n  namespacePrefix?: string\n) => {\n  const locale = resolveServerLocale();\n  const content = useDictionaryDynamicBase(\n    dictionaryPromise as never,\n    key as never,\n    locale as never\n  );\n\n  return createDictionaryTranslator(\n    locale,\n    content,\n    namespacePrefix\n  );\n}) as UseDictionaryDynamic;\n"],"mappings":";;;;;;;;;;AA6BA,MAAa,yBACX,mBACA,KACA,oBACG;CACH,MAAM,SAASA,uDAAoB;CACnC,MAAM,cAAUC,2CACd,mBACA,KACA,MACF;CAEA,WAAOC,+CACL,QACA,SACA,eACF;AACF"}

package/dist/cjs/react-server/useLocale.cjs

@@ -0,0 +1,13 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_react_server_resolveLocale = require('./resolveLocale.cjs');
+
+//#region src/react-server/useLocale.ts
+/**
+* Server counterpart of `useLocale`, resolved from the `[locale]` route segment
+* forwarded through `setRequestLocale` when the app provides one.
+*/
+const useLocale = () => require_react_server_resolveLocale.resolveServerLocale();
+
+//#endregion
+exports.useLocale = useLocale;
+//# sourceMappingURL=useLocale.cjs.map

package/dist/cjs/react-server/useLocale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.cjs","names":["resolveServerLocale"],"sources":["../../../src/react-server/useLocale.ts"],"sourcesContent":["import type { useLocale as _useLocale } from 'next-intl';\nimport { resolveServerLocale } from './resolveLocale';\n\n/**\n * Server counterpart of `useLocale`, resolved from the `[locale]` route segment\n * forwarded through `setRequestLocale` when the app provides one.\n */\nexport const useLocale: typeof _useLocale = () =>\n  resolveServerLocale() as ReturnType<typeof _useLocale>;\n"],"mappings":";;;;;;;;AAOA,MAAa,kBACXA,uDAAoB"}

package/dist/cjs/react-server/useTranslations.cjs

@@ -0,0 +1,42 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_react_server_resolveLocale = require('./resolveLocale.cjs');
+let _intlayer_use_intl = require("@intlayer/use-intl");
+let next_intlayer_server = require("next-intlayer/server");
+
+//#region src/react-server/useTranslations.ts
+/** Splits `'about.counter'` into the dictionary key and its key prefix. */
+const splitNamespace = (namespace) => {
+	const dotPosition = namespace.indexOf(".");
+	if (dotPosition === -1) return [namespace, void 0];
+	return [namespace.slice(0, dotPosition), namespace.slice(dotPosition + 1)];
+};
+/**
+* Server counterpart of `useTranslations`.
+*
+* next-intl's `useTranslations` is isomorphic — the same component code runs in
+* a Server or a Client Component — so the adapter has to be too. Without this
+* every component calling it is forced across the client boundary, which drags
+* its dictionary into a client chunk that Next shares across every locale.
+*
+* The optimize pass normally rewrites these calls to `useDictionary` with the
+* dictionary inlined; this runtime path covers the calls it could not resolve
+* statically (a dynamic namespace, or an unoptimized build).
+*/
+const useTranslations = ((namespace) => {
+	const locale = require_react_server_resolveLocale.resolveServerLocale();
+	if (!namespace) {
+		const rootTranslator = (key, values) => {
+			const [dictionaryKey, keyPrefix] = splitNamespace(key);
+			const content = (0, next_intlayer_server.useIntlayer)(dictionaryKey, locale);
+			return (0, _intlayer_use_intl.createDictionaryTranslator)(locale, content, void 0)(keyPrefix ?? "", values);
+		};
+		return rootTranslator;
+	}
+	const [dictionaryKey, keyPrefix] = splitNamespace(namespace);
+	const content = (0, next_intlayer_server.useIntlayer)(dictionaryKey, locale);
+	return (0, _intlayer_use_intl.createDictionaryTranslator)(locale, content, keyPrefix);
+});
+
+//#endregion
+exports.useTranslations = useTranslations;
+//# sourceMappingURL=useTranslations.cjs.map

package/dist/cjs/react-server/useTranslations.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTranslations.cjs","names":["resolveServerLocale","useIntlayer","createDictionaryTranslator"],"sources":["../../../src/react-server/useTranslations.ts"],"sourcesContent":["import type { DictionaryKeys } from '@intlayer/types/module_augmentation';\nimport {\n  createDictionaryTranslator,\n  type LooseTranslateFunction,\n  type TranslateFunction,\n  type TranslateFunctionForNamespace,\n} from '@intlayer/use-intl';\nimport { useIntlayer } from 'next-intlayer/server';\nimport { resolveServerLocale } from './resolveLocale';\n\ntype UseTranslations = {\n  <N extends DictionaryKeys>(namespace: N): TranslateFunction<N>;\n  <N extends `${string}.${string}`>(\n    namespace: N\n  ): TranslateFunctionForNamespace<N>;\n  (): LooseTranslateFunction;\n};\n\n/** Splits `'about.counter'` into the dictionary key and its key prefix. */\nconst splitNamespace = (namespace: string): [string, string | undefined] => {\n  const dotPosition = namespace.indexOf('.');\n  if (dotPosition === -1) return [namespace, undefined];\n  return [namespace.slice(0, dotPosition), namespace.slice(dotPosition + 1)];\n};\n\n/**\n * Server counterpart of `useTranslations`.\n *\n * next-intl's `useTranslations` is isomorphic — the same component code runs in\n * a Server or a Client Component — so the adapter has to be too. Without this\n * every component calling it is forced across the client boundary, which drags\n * its dictionary into a client chunk that Next shares across every locale.\n *\n * The optimize pass normally rewrites these calls to `useDictionary` with the\n * dictionary inlined; this runtime path covers the calls it could not resolve\n * statically (a dynamic namespace, or an unoptimized build).\n */\nexport const useTranslations = ((namespace?: string) => {\n  const locale = resolveServerLocale();\n\n  if (!namespace) {\n    // Root scope: the first segment of each message id names the dictionary,\n    // so the lookup can only happen per call.\n    const rootTranslator = (key: string, values?: Record<string, unknown>) => {\n      const [dictionaryKey, keyPrefix] = splitNamespace(key);\n      const content = useIntlayer(dictionaryKey as never, locale as never);\n      const translate = createDictionaryTranslator(locale, content, undefined);\n      return translate(keyPrefix ?? '', values as never);\n    };\n    return rootTranslator as unknown as LooseTranslateFunction;\n  }\n\n  const [dictionaryKey, keyPrefix] = splitNamespace(namespace);\n  const content = useIntlayer(dictionaryKey as never, locale as never);\n\n  return createDictionaryTranslator(locale, content, keyPrefix);\n}) as UseTranslations;\n"],"mappings":";;;;;;;AAmBA,MAAM,kBAAkB,cAAoD;CAC1E,MAAM,cAAc,UAAU,QAAQ,GAAG;CACzC,IAAI,gBAAgB,IAAI,OAAO,CAAC,WAAW,MAAS;CACpD,OAAO,CAAC,UAAU,MAAM,GAAG,WAAW,GAAG,UAAU,MAAM,cAAc,CAAC,CAAC;AAC3E;;;;;;;;;;;;;AAcA,MAAa,oBAAoB,cAAuB;CACtD,MAAM,SAASA,uDAAoB;CAEnC,IAAI,CAAC,WAAW;EAGd,MAAM,kBAAkB,KAAa,WAAqC;GACxE,MAAM,CAAC,eAAe,aAAa,eAAe,GAAG;GACrD,MAAM,cAAUC,kCAAY,eAAwB,MAAe;GAEnE,WADkBC,+CAA2B,QAAQ,SAAS,MAC/C,CAAC,CAAC,aAAa,IAAI,MAAe;EACnD;EACA,OAAO;CACT;CAEA,MAAM,CAAC,eAAe,aAAa,eAAe,SAAS;CAC3D,MAAM,cAAUD,kCAAY,eAAwB,MAAe;CAEnE,WAAOC,+CAA2B,QAAQ,SAAS,SAAS;AAC9D"}

package/dist/cjs/server/react/helpers.cjs

@@ -0,0 +1,23 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_server_react_useLocale = require('./useLocale.cjs');
+let _intlayer_use_intl = require("@intlayer/use-intl");
+
+//#region src/server/react/helpers.ts
+/**
+* Server counterparts of use-intl's ambient hooks. They mirror the client
+* versions' signatures so the same component code type-checks on both sides.
+*/
+const useFormatter = (() => (0, _intlayer_use_intl.createFormatter)({ locale: require_server_react_useLocale.useLocale() }));
+/** Current time on the server render. */
+const useNow = (() => /* @__PURE__ */ new Date());
+/**
+* Time zone the formatters resolve against — the same value the async
+* `getTimeZone()` reports, so both server surfaces agree.
+*/
+const useTimeZone = (() => Intl.DateTimeFormat().resolvedOptions().timeZone);
+
+//#endregion
+exports.useFormatter = useFormatter;
+exports.useNow = useNow;
+exports.useTimeZone = useTimeZone;
+//# sourceMappingURL=helpers.cjs.map

package/dist/cjs/server/react/helpers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.cjs","names":["createFormatter","useLocale"],"sources":["../../../../src/server/react/helpers.ts"],"sourcesContent":["import { createFormatter } from '@intlayer/use-intl';\nimport { useLocale } from './useLocale';\n\n/**\n * Server counterparts of use-intl's ambient hooks. They mirror the client\n * versions' signatures so the same component code type-checks on both sides.\n */\nexport const useFormatter: typeof import('@intlayer/use-intl').useFormatter =\n  (() => createFormatter({ locale: useLocale() as string })) as never;\n\n/** Current time on the server render. */\nexport const useNow: typeof import('@intlayer/use-intl').useNow = (() =>\n  new Date()) as never;\n\n/**\n * Time zone the formatters resolve against — the same value the async\n * `getTimeZone()` reports, so both server surfaces agree.\n */\nexport const useTimeZone: typeof import('@intlayer/use-intl').useTimeZone =\n  (() => Intl.DateTimeFormat().resolvedOptions().timeZone) as never;\n"],"mappings":";;;;;;;;;AAOA,MAAa,0BACJA,oCAAgB,EAAE,QAAQC,yCAAU,EAAY,CAAC;;AAG1D,MAAa,gCACX,IAAI,KAAK;;;;;AAMX,MAAa,qBACJ,KAAK,eAAe,CAAC,CAAC,gBAAgB,CAAC,CAAC"}

package/dist/cjs/server/react/index.cjs

@@ -0,0 +1,61 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_routing = require('../../routing.cjs');
+const require_client_NextIntlClientProvider = require('../../client/NextIntlClientProvider.cjs');
+const require_server_react_useTranslations = require('./useTranslations.cjs');
+const require_server_react_useLocale = require('./useLocale.cjs');
+const require_server_react_helpers = require('./helpers.cjs');
+const require_server_react_useDictionaryDynamic = require('./useDictionaryDynamic.cjs');
+const require_server_react_useDictionary = require('./useDictionary.cjs');
+let _intlayer_use_intl = require("@intlayer/use-intl");
+
+Object.defineProperty(exports, 'IntlError', {
+  enumerable: true,
+  get: function () {
+    return _intlayer_use_intl.IntlError;
+  }
+});
+Object.defineProperty(exports, 'IntlErrorCode', {
+  enumerable: true,
+  get: function () {
+    return _intlayer_use_intl.IntlErrorCode;
+  }
+});
+exports.NextIntlClientProvider = require_client_NextIntlClientProvider.NextIntlClientProvider;
+Object.defineProperty(exports, 'createFormatter', {
+  enumerable: true,
+  get: function () {
+    return _intlayer_use_intl.createFormatter;
+  }
+});
+Object.defineProperty(exports, 'createTranslator', {
+  enumerable: true,
+  get: function () {
+    return _intlayer_use_intl.createTranslator;
+  }
+});
+exports.defineRouting = require_routing.defineRouting;
+Object.defineProperty(exports, 'hasLocale', {
+  enumerable: true,
+  get: function () {
+    return _intlayer_use_intl.hasLocale;
+  }
+});
+Object.defineProperty(exports, 'initializeConfig', {
+  enumerable: true,
+  get: function () {
+    return _intlayer_use_intl.initializeConfig;
+  }
+});
+exports.useDictionary = require_server_react_useDictionary.useDictionary;
+exports.useDictionaryDynamic = require_server_react_useDictionaryDynamic.useDictionaryDynamic;
+exports.useFormatter = require_server_react_helpers.useFormatter;
+exports.useLocale = require_server_react_useLocale.useLocale;
+Object.defineProperty(exports, 'useMessages', {
+  enumerable: true,
+  get: function () {
+    return _intlayer_use_intl.useMessages;
+  }
+});
+exports.useNow = require_server_react_helpers.useNow;
+exports.useTimeZone = require_server_react_helpers.useTimeZone;
+exports.useTranslations = require_server_react_useTranslations.useTranslations;

package/dist/cjs/server/react/resolveLocale.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_server_requestLocaleCache = require('../requestLocaleCache.cjs');
+let next_intlayer_server = require("next-intlayer/server");
+
+//#region src/server/react/resolveLocale.ts
+/**
+* Locale for the synchronous server hooks, resolved the way `getLocale()`
+* resolves it — so server-rendered output and the client provider never
+* disagree about which locale the request is in.
+*
+* 1. The locale forwarded through `setRequestLocale(locale)` (the `[locale]`
+*    route segment), which is next-intl's source of truth for URL routing.
+* 2. Otherwise Intlayer's ambient locale (server context, then the request).
+*
+* The second rung must stay lazy. It ends in `headers()` / `cookies()`, which
+* opts the route into dynamic rendering: evaluating it eagerly took this
+* package's own benchmark app from 14 prerendered pages to 0.
+*/
+const resolveServerLocale = () => {
+	const requestLocale = require_server_requestLocaleCache.getCachedRequestLocale();
+	if (requestLocale) return requestLocale;
+	return (0, next_intlayer_server.useLocale)().locale;
+};
+
+//#endregion
+exports.resolveServerLocale = resolveServerLocale;
+//# sourceMappingURL=resolveLocale.cjs.map

package/dist/cjs/server/react/resolveLocale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveLocale.cjs","names":["getCachedRequestLocale","readAmbientLocale"],"sources":["../../../../src/server/react/resolveLocale.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/types/module_augmentation';\n// Not a React hook despite the name: `next-intlayer/server` prefixes its\n// server readers with `use` for symmetry with the client API, but they hold no\n// positional state — its own `resolveFallbackLocale` documents that this is\n// exactly what lets them run conditionally. Bound to a plain name here so the\n// call below reads as what it is.\nimport { useLocale as readAmbientLocale } from 'next-intlayer/server';\nimport { getCachedRequestLocale } from '../requestLocaleCache';\n\n/**\n * Locale for the synchronous server hooks, resolved the way `getLocale()`\n * resolves it — so server-rendered output and the client provider never\n * disagree about which locale the request is in.\n *\n * 1. The locale forwarded through `setRequestLocale(locale)` (the `[locale]`\n *    route segment), which is next-intl's source of truth for URL routing.\n * 2. Otherwise Intlayer's ambient locale (server context, then the request).\n *\n * The second rung must stay lazy. It ends in `headers()` / `cookies()`, which\n * opts the route into dynamic rendering: evaluating it eagerly took this\n * package's own benchmark app from 14 prerendered pages to 0.\n */\nexport const resolveServerLocale = (): LocalesValues => {\n  const requestLocale = getCachedRequestLocale();\n  if (requestLocale) return requestLocale as LocalesValues;\n\n  return readAmbientLocale().locale as LocalesValues;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAsBA,MAAa,4BAA2C;CACtD,MAAM,gBAAgBA,yDAAuB;CAC7C,IAAI,eAAe,OAAO;CAE1B,WAAOC,gCAAkB,CAAC,CAAC;AAC7B"}

package/dist/cjs/server/react/useDictionary.cjs

@@ -0,0 +1,23 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_server_react_resolveLocale = require('./resolveLocale.cjs');
+let _intlayer_use_intl = require("@intlayer/use-intl");
+let next_intlayer_server = require("next-intlayer/server");
+
+//#region src/server/react/useDictionary.ts
+/**
+* Server counterpart of `@intlayer/use-intl`'s `useDictionary`.
+*
+* The optimize pass rewrites every `useTranslations(...)` call to this helper
+* with the dictionary pre-imported. Resolving it here — rather than in a client
+* component — keeps the dictionary out of the client bundle entirely: the
+* server renders the text and only the rendered output crosses the boundary.
+*/
+const useDictionary = ((dictionary, namespacePrefix) => {
+	const locale = require_server_react_resolveLocale.resolveServerLocale();
+	const content = (0, next_intlayer_server.useDictionary)(dictionary, locale);
+	return (0, _intlayer_use_intl.createDictionaryTranslator)(locale, content, namespacePrefix);
+});
+
+//#endregion
+exports.useDictionary = useDictionary;
+//# sourceMappingURL=useDictionary.cjs.map

package/dist/cjs/server/react/useDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionary.cjs","names":["resolveServerLocale","useDictionaryBase","createDictionaryTranslator"],"sources":["../../../../src/server/react/useDictionary.ts"],"sourcesContent":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type { DictionaryKeys } from '@intlayer/types/module_augmentation';\nimport {\n  createDictionaryTranslator,\n  type ScopedTranslateFunction,\n  type TranslateFunction,\n} from '@intlayer/use-intl';\nimport { useDictionary as useDictionaryBase } from 'next-intlayer/server';\nimport { resolveServerLocale } from './resolveLocale';\n\n/**\n * Overload set mirroring the client `useDictionary` exactly, so the optimize\n * pass can emit the same call shape whichever side of the boundary the\n * component ends up on.\n */\ntype UseDictionary = {\n  <T extends Dictionary>(\n    dictionary: T\n  ): TranslateFunction<T['key'] & DictionaryKeys>;\n  <T extends Dictionary, Prefix extends string>(\n    dictionary: T,\n    namespacePrefix: Prefix\n  ): ScopedTranslateFunction<T['key'] & DictionaryKeys, Prefix>;\n};\n\n/**\n * Server counterpart of `@intlayer/use-intl`'s `useDictionary`.\n *\n * The optimize pass rewrites every `useTranslations(...)` call to this helper\n * with the dictionary pre-imported. Resolving it here — rather than in a client\n * component — keeps the dictionary out of the client bundle entirely: the\n * server renders the text and only the rendered output crosses the boundary.\n */\nexport const useDictionary = (<T extends Dictionary>(\n  dictionary: T,\n  namespacePrefix?: string\n) => {\n  const locale = resolveServerLocale();\n  const content = useDictionaryBase(dictionary, locale as never);\n\n  return createDictionaryTranslator(locale, content, namespacePrefix);\n}) as UseDictionary;\n"],"mappings":";;;;;;;;;;;;;;AAiCA,MAAa,kBACX,YACA,oBACG;CACH,MAAM,SAASA,uDAAoB;CACnC,MAAM,cAAUC,oCAAkB,YAAY,MAAe;CAE7D,WAAOC,+CAA2B,QAAQ,SAAS,eAAe;AACpE"}

package/dist/cjs/server/react/useDictionaryDynamic.cjs

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_server_react_resolveLocale = require('./resolveLocale.cjs');
+let _intlayer_use_intl = require("@intlayer/use-intl");
+let next_intlayer_server = require("next-intlayer/server");
+
+//#region src/server/react/useDictionaryDynamic.ts
+/**
+* Server counterpart of `useDictionaryDynamic`, emitted by the optimize pass
+* for dictionaries on the per-locale loader.
+*/
+const useDictionaryDynamic = ((dictionaryPromise, key, namespacePrefix) => {
+	const locale = require_server_react_resolveLocale.resolveServerLocale();
+	const content = (0, next_intlayer_server.useDictionaryDynamic)(dictionaryPromise, key, locale);
+	return (0, _intlayer_use_intl.createDictionaryTranslator)(locale, content, namespacePrefix);
+});
+
+//#endregion
+exports.useDictionaryDynamic = useDictionaryDynamic;
+//# sourceMappingURL=useDictionaryDynamic.cjs.map

package/dist/cjs/server/react/useDictionaryDynamic.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionaryDynamic.cjs","names":["resolveServerLocale","useDictionaryDynamicBase","createDictionaryTranslator"],"sources":["../../../../src/server/react/useDictionaryDynamic.ts"],"sourcesContent":["import type { Dictionary } from '@intlayer/types/dictionary';\nimport type { DictionaryKeys } from '@intlayer/types/module_augmentation';\nimport {\n  createDictionaryTranslator,\n  type ScopedTranslateFunction,\n  type TranslateFunction,\n} from '@intlayer/use-intl';\nimport { useDictionaryDynamic as useDictionaryDynamicBase } from 'next-intlayer/server';\nimport { resolveServerLocale } from './resolveLocale';\n\ntype UseDictionaryDynamic = {\n  <T extends Dictionary, K extends DictionaryKeys>(\n    dictionaryPromise: Record<string, () => Promise<T>>,\n    key: K\n  ): TranslateFunction<K>;\n  <T extends Dictionary, K extends DictionaryKeys, Prefix extends string>(\n    dictionaryPromise: Record<string, () => Promise<T>>,\n    key: K,\n    namespacePrefix: Prefix\n  ): ScopedTranslateFunction<K, Prefix>;\n};\n\n/**\n * Server counterpart of `useDictionaryDynamic`, emitted by the optimize pass\n * for dictionaries on the per-locale loader.\n */\nexport const useDictionaryDynamic = ((\n  dictionaryPromise: Record<string, () => Promise<Dictionary>>,\n  key: string,\n  namespacePrefix?: string\n) => {\n  const locale = resolveServerLocale();\n  const content = useDictionaryDynamicBase(\n    dictionaryPromise as never,\n    key as never,\n    locale as never\n  );\n\n  return createDictionaryTranslator(locale, content, namespacePrefix);\n}) as UseDictionaryDynamic;\n"],"mappings":";;;;;;;;;;AA0BA,MAAa,yBACX,mBACA,KACA,oBACG;CACH,MAAM,SAASA,uDAAoB;CACnC,MAAM,cAAUC,2CACd,mBACA,KACA,MACF;CAEA,WAAOC,+CAA2B,QAAQ,SAAS,eAAe;AACpE"}

package/dist/cjs/server/react/useLocale.cjs

@@ -0,0 +1,13 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_server_react_resolveLocale = require('./resolveLocale.cjs');
+
+//#region src/server/react/useLocale.ts
+/**
+* Server counterpart of `useLocale`, resolved from the `[locale]` route segment
+* forwarded through `setRequestLocale` when the app provides one.
+*/
+const useLocale = () => require_server_react_resolveLocale.resolveServerLocale();
+
+//#endregion
+exports.useLocale = useLocale;
+//# sourceMappingURL=useLocale.cjs.map

package/dist/cjs/server/react/useLocale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.cjs","names":["resolveServerLocale"],"sources":["../../../../src/server/react/useLocale.ts"],"sourcesContent":["import type { useLocale as _useLocale } from 'next-intl';\nimport { resolveServerLocale } from './resolveLocale';\n\n/**\n * Server counterpart of `useLocale`, resolved from the `[locale]` route segment\n * forwarded through `setRequestLocale` when the app provides one.\n */\nexport const useLocale: typeof _useLocale = () =>\n  resolveServerLocale() as ReturnType<typeof _useLocale>;\n"],"mappings":";;;;;;;;AAOA,MAAa,kBACXA,uDAAoB"}