next-intl 3.25.0 → 4.0.0-beta-00a79d4

package/dist/{development → esm/development}/navigation/shared/utils.js

@@ -1,8 +1,4 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var utils = require('../../shared/utils.js');
+import { getSortedPathnames, matchesPathname, isLocalizableHref, prefixPathname, getLocalePrefix, normalizeTrailingSlash } from '../../shared/utils.js';
 
 // Minor false positive: A route that has both optional and
 // required params will allow optional params.
@@ -32,14 +28,13 @@ function serializeSearchParams(searchParams) {
   }
   return '?' + urlSearchParams.toString();
 }
-function compileLocalizedPathname(_ref) {
-  let {
-    pathname,
-    locale,
-    params,
-    pathnames,
-    query
-  } = _ref;
+function compileLocalizedPathname({
+  pathname,
+  locale,
+  params,
+  pathnames,
+  query
+}) {
   function getNamedPath(value) {
     let namedPath = pathnames[value];
     if (!namedPath) {
@@ -52,14 +47,13 @@ function compileLocalizedPathname(_ref) {
     const template = typeof namedPath === 'string' ? namedPath : namedPath[locale];
     let compiled = template;
     if (params) {
-      Object.entries(params).forEach(_ref2 => {
-        let [key, value] = _ref2;
+      Object.entries(params).forEach(([key, value]) => {
         let regexp, replacer;
         if (Array.isArray(value)) {
-          regexp = "(\\[)?\\[...".concat(key, "\\](\\])?");
+          regexp = `(\\[)?\\[...${key}\\](\\])?`;
           replacer = value.map(v => String(v)).join('/');
         } else {
-          regexp = "\\[".concat(key, "\\]");
+          regexp = `\\[${key}\\]`;
           replacer = String(value);
         }
         compiled = compiled.replace(new RegExp(regexp, 'g'), replacer);
@@ -68,10 +62,10 @@ function compileLocalizedPathname(_ref) {
 
     // Clean up optional catch-all segments that were not replaced
     compiled = compiled.replace(/\[\[\.\.\..+\]\]/g, '');
-    compiled = utils.normalizeTrailingSlash(compiled);
+    compiled = normalizeTrailingSlash(compiled);
     if (compiled.includes('[')) {
       // Next.js throws anyway, therefore better provide a more helpful error message
-      throw new Error("Insufficient params provided for localized pathname.\nTemplate: ".concat(template, "\nParams: ").concat(JSON.stringify(params)));
+      throw new Error(`Insufficient params provided for localized pathname.\nTemplate: ${template}\nParams: ${JSON.stringify(params)}`);
     }
     if (query) {
       compiled += serializeSearchParams(query);
@@ -97,25 +91,24 @@ function compileLocalizedPathname(_ref) {
   }
 }
 function getRoute(locale, pathname, pathnames) {
-  const sortedPathnames = utils.getSortedPathnames(Object.keys(pathnames));
+  const sortedPathnames = getSortedPathnames(Object.keys(pathnames));
   const decoded = decodeURI(pathname);
   for (const internalPathname of sortedPathnames) {
     const localizedPathnamesOrPathname = pathnames[internalPathname];
     if (typeof localizedPathnamesOrPathname === 'string') {
       const localizedPathname = localizedPathnamesOrPathname;
-      if (utils.matchesPathname(localizedPathname, decoded)) {
+      if (matchesPathname(localizedPathname, decoded)) {
         return internalPathname;
       }
     } else {
-      if (utils.matchesPathname(localizedPathnamesOrPathname[locale], decoded)) {
+      if (matchesPathname(localizedPathnamesOrPathname[locale], decoded)) {
         return internalPathname;
       }
     }
   }
   return pathname;
 }
-function getBasePath(pathname) {
-  let windowPathname = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : window.location.pathname;
+function getBasePath(pathname, windowPathname = window.location.pathname) {
   if (pathname === '/') {
     return windowPathname;
   } else {
@@ -129,7 +122,7 @@ function applyPathnamePrefix(pathname, locale, routing, domain, force) {
   let shouldPrefix;
   if (force !== undefined) {
     shouldPrefix = force;
-  } else if (utils.isLocalizableHref(pathname)) {
+  } else if (isLocalizableHref(pathname)) {
     if (mode === 'always') {
       shouldPrefix = true;
     } else if (mode === 'as-needed') {
@@ -147,19 +140,12 @@ function applyPathnamePrefix(pathname, locale, routing, domain, force) {
       shouldPrefix = defaultLocale !== locale;
     }
   }
-  return shouldPrefix ? utils.prefixPathname(utils.getLocalePrefix(locale, routing.localePrefix), pathname) : pathname;
+  return shouldPrefix ? prefixPathname(getLocalePrefix(locale, routing.localePrefix), pathname) : pathname;
 }
 function validateReceivedConfig(config) {
-  var _config$localePrefix;
-  if (((_config$localePrefix = config.localePrefix) === null || _config$localePrefix === void 0 ? void 0 : _config$localePrefix.mode) === 'as-needed' && !('defaultLocale' in config)) {
+  if (config.localePrefix?.mode === 'as-needed' && !('defaultLocale' in config)) {
     throw new Error("`localePrefix: 'as-needed' requires a `defaultLocale`.");
   }
 }
 
-exports.applyPathnamePrefix = applyPathnamePrefix;
-exports.compileLocalizedPathname = compileLocalizedPathname;
-exports.getBasePath = getBasePath;
-exports.getRoute = getRoute;
-exports.normalizeNameOrNameWithParams = normalizeNameOrNameWithParams;
-exports.serializeSearchParams = serializeSearchParams;
-exports.validateReceivedConfig = validateReceivedConfig;
+export { applyPathnamePrefix, compileLocalizedPathname, getBasePath, getRoute, normalizeNameOrNameWithParams, serializeSearchParams, validateReceivedConfig };

package/dist/esm/development/navigation.react-client.js

@@ -0,0 +1 @@
+export { default as createNavigation } from './navigation/react-client/createNavigation.js';

package/dist/esm/development/navigation.react-server.js

@@ -0,0 +1 @@
+export { default as createNavigation } from './navigation/react-server/createNavigation.js';

package/dist/esm/development/plugin/createMessagesDeclaration.js

@@ -0,0 +1,61 @@
+import fs from 'fs';
+import path from 'path';
+import { watch } from 'chokidar';
+import { throwError } from './utils.js';
+
+function runOnce(fn) {
+  if (process.env._NEXT_INTL_COMPILE_MESSAGES === '1') {
+    return;
+  }
+  process.env._NEXT_INTL_COMPILE_MESSAGES = '1';
+  fn();
+}
+function createMessagesDeclaration(messagesPath) {
+  const fullPath = path.resolve(messagesPath);
+  if (!fs.existsSync(fullPath)) {
+    throwError(`\`createMessagesDeclaration\` points to a non-existent file: ${fullPath}`);
+  }
+  if (!fullPath.endsWith('.json')) {
+    throwError(`\`createMessagesDeclaration\` needs to point to a JSON file. Received: ${fullPath}`);
+  }
+  const isDev = process.argv.includes('dev');
+  const isBuild = process.argv.includes('build');
+  if (!isDev && !isBuild) {
+    return;
+  }
+
+  // Next.js can call the Next.js config multiple
+  // times - ensure we only run once.
+  runOnce(() => {
+    compileDeclaration(messagesPath);
+    if (isDev) {
+      startWatching(messagesPath);
+    }
+  });
+}
+function startWatching(messagesPath) {
+  const watcher = watch(messagesPath);
+  watcher.on('change', () => {
+    compileDeclaration(messagesPath, true);
+  });
+  process.on('exit', () => {
+    void watcher.close();
+  });
+}
+function compileDeclaration(messagesPath, async = false) {
+  const declarationPath = messagesPath.replace(/\.json$/, '.d.json.ts');
+  function createDeclaration(content) {
+    return `// This file is auto-generated by next-intl, do not edit directly.
+// See: https://next-intl-docs.vercel.app/docs/workflows/typescript#messages-arguments
+
+declare const messages: ${content.trim()};
+export default messages;`;
+  }
+  if (async) {
+    return fs.promises.readFile(messagesPath, 'utf-8').then(content => fs.promises.writeFile(declarationPath, createDeclaration(content)));
+  }
+  const content = fs.readFileSync(messagesPath, 'utf-8');
+  fs.writeFileSync(declarationPath, createDeclaration(content));
+}
+
+export { createMessagesDeclaration as default };

package/dist/esm/development/plugin/createNextIntlPlugin.js

@@ -0,0 +1,23 @@
+import createMessagesDeclaration from './createMessagesDeclaration.js';
+import getNextConfig from './getNextConfig.js';
+import { warn } from './utils.js';
+
+function initPlugin(pluginConfig, nextConfig) {
+  if (nextConfig?.i18n != null) {
+    warn("\n[next-intl] An `i18n` property was found in your Next.js config. This likely causes conflicts and should therefore be removed if you use the App Router.\n\nIf you're in progress of migrating from the Pages Router, you can refer to this example: https://next-intl-docs.vercel.app/examples#app-router-migration\n");
+  }
+  if (pluginConfig.experimental?.createMessagesDeclaration) {
+    createMessagesDeclaration(pluginConfig.experimental.createMessagesDeclaration);
+  }
+  return getNextConfig(pluginConfig, nextConfig);
+}
+function createNextIntlPlugin(i18nPathOrConfig = {}) {
+  const config = typeof i18nPathOrConfig === 'string' ? {
+    requestConfig: i18nPathOrConfig
+  } : i18nPathOrConfig;
+  return function withNextIntl(nextConfig) {
+    return initPlugin(config, nextConfig);
+  };
+}
+
+export { createNextIntlPlugin as default };

package/dist/esm/development/plugin/getNextConfig.js

@@ -0,0 +1,82 @@
+import fs from 'fs';
+import path from 'path';
+import { throwError } from './utils.js';
+
+function withExtensions(localPath) {
+  return [`${localPath}.ts`, `${localPath}.tsx`, `${localPath}.js`, `${localPath}.jsx`];
+}
+function resolveI18nPath(providedPath, cwd) {
+  function resolvePath(pathname) {
+    const parts = [];
+    if (cwd) parts.push(cwd);
+    parts.push(pathname);
+    return path.resolve(...parts);
+  }
+  function pathExists(pathname) {
+    return fs.existsSync(resolvePath(pathname));
+  }
+  if (providedPath) {
+    if (!pathExists(providedPath)) {
+      throwError(`Could not find i18n config at ${providedPath}, please provide a valid path.`);
+    }
+    return providedPath;
+  } else {
+    for (const candidate of [...withExtensions('./i18n/request'), ...withExtensions('./src/i18n/request')]) {
+      if (pathExists(candidate)) {
+        return candidate;
+      }
+    }
+    throwError(`Could not locate request configuration module.\n\nThis path is supported by default: ./(src/)i18n/request.{js,jsx,ts,tsx}\n\nAlternatively, you can specify a custom location in your Next.js config:\n\nconst withNextIntl = createNextIntlPlugin(
+
+Alternatively, you can specify a custom location in your Next.js config:
+
+const withNextIntl = createNextIntlPlugin(
+  './path/to/i18n/request.tsx'
+);`);
+  }
+}
+function getNextConfig(pluginConfig, nextConfig) {
+  const useTurbo = process.env.TURBOPACK != null;
+  const nextIntlConfig = {};
+
+  // Assign alias for `next-intl/config`
+  if (useTurbo) {
+    if (pluginConfig.requestConfig?.startsWith('/')) {
+      throwError("Turbopack support for next-intl currently does not support absolute paths, please provide a relative one (e.g. './src/i18n/config.ts').\n\nFound: " + pluginConfig.requestConfig);
+    }
+
+    // `NextConfig['turbo']` is stable in Next.js 15. In case the
+    // experimental feature is removed in the future, we should
+    // replace this accordingly in a future major version.
+    nextIntlConfig.experimental = {
+      ...nextConfig?.experimental,
+      turbo: {
+        ...nextConfig?.experimental?.turbo,
+        resolveAlias: {
+          ...nextConfig?.experimental?.turbo?.resolveAlias,
+          // Turbo aliases don't work with absolute
+          // paths (see error handling above)
+          'next-intl/config': resolveI18nPath(pluginConfig.requestConfig)
+        }
+      }
+    };
+  } else {
+    nextIntlConfig.webpack = function webpack(...[config, options]) {
+      // Webpack requires absolute paths
+      config.resolve.alias['next-intl/config'] = path.resolve(config.context, resolveI18nPath(pluginConfig.requestConfig, config.context));
+      if (typeof nextConfig?.webpack === 'function') {
+        return nextConfig.webpack(config, options);
+      }
+      return config;
+    };
+  }
+
+  // Forward config
+  nextIntlConfig.env = {
+    ...nextConfig?.env,
+    _next_intl_trailing_slash: nextConfig?.trailingSlash ? 'true' : undefined
+  };
+  return Object.assign({}, nextConfig, nextIntlConfig);
+}
+
+export { getNextConfig as default };

package/dist/esm/development/plugin/utils.js

@@ -0,0 +1,11 @@
+function formatMessage(message) {
+  return `\n[next-intl] ${message}\n`;
+}
+function throwError(message) {
+  throw new Error(formatMessage(message));
+}
+function warn(message) {
+  console.warn(formatMessage(message));
+}
+
+export { throwError, warn };

package/dist/esm/development/plugin.js

@@ -0,0 +1 @@
+export { default } from './plugin/createNextIntlPlugin.js';

package/dist/esm/development/react-client/index.js

@@ -0,0 +1,35 @@
+import { useTranslations as useTranslations$1, useFormatter as useFormatter$1 } from 'use-intl';
+export * from 'use-intl';
+
+/**
+ * This is the main entry file when non-'react-server'
+ * environments import from 'next-intl'.
+ *
+ * Maintainer notes:
+ * - Make sure this mirrors the API from 'react-server'.
+ * - Make sure everything exported from this module is
+ *   supported in all Next.js versions that are supported.
+ */
+
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+function callHook(name, hook) {
+  return (...args) => {
+    try {
+      return hook(...args);
+    } catch {
+      throw new Error(`Failed to call \`${name}\` because the context from \`NextIntlClientProvider\` was not found.
+
+This can happen because:
+1) You intended to render this component as a Server Component, the render
+   failed, and therefore React attempted to render the component on the client
+   instead. If this is the case, check the console for server errors.
+2) You intended to render this component on the client side, but no context was found.
+   Learn more about this error here: https://next-intl-docs.vercel.app/docs/environments/server-client-components#missing-context` );
+    }
+  };
+}
+const useTranslations = callHook('useTranslations', useTranslations$1);
+const useFormatter = callHook('useFormatter', useFormatter$1);
+
+export { useFormatter, useTranslations };

package/dist/esm/development/react-server/NextIntlClientProviderServer.js

@@ -0,0 +1,31 @@
+import getConfigNow from '../server/react-server/getConfigNow.js';
+import getFormats from '../server/react-server/getFormats.js';
+import NextIntlClientProvider from '../shared/NextIntlClientProvider.js';
+import { jsx } from 'react/jsx-runtime';
+import getLocaleCached from '../server/react-server/getLocale.js';
+import getTimeZone from '../server/react-server/getTimeZone.js';
+
+async function NextIntlClientProviderServer({
+  formats,
+  locale,
+  now,
+  timeZone,
+  ...rest
+}) {
+  return /*#__PURE__*/jsx(NextIntlClientProvider
+  // We need to be careful about potentially reading from headers here.
+  // See https://github.com/amannn/next-intl/issues/631
+  , {
+    formats: formats === undefined ? await getFormats() : formats,
+    locale: locale ?? (await getLocaleCached())
+    // Note that we don't assign a default for `now` here,
+    // we only read one from the request config - if any.
+    // Otherwise this would cause a `dynamicIO` error.
+    ,
+    now: now ?? (await getConfigNow()),
+    timeZone: timeZone ?? (await getTimeZone()),
+    ...rest
+  });
+}
+
+export { NextIntlClientProviderServer as default };

package/dist/esm/development/react-server/useConfig.js

@@ -0,0 +1,21 @@
+import getConfig from '../server/react-server/getConfig.js';
+import use from '../shared/use.js';
+
+function useHook(hookName, promise) {
+  try {
+    return use(promise);
+  } catch (error) {
+    if (error instanceof TypeError && error.message.includes("Cannot read properties of null (reading 'use')")) {
+      throw new Error(`\`${hookName}\` is not callable within an async component. Please refer to https://next-intl-docs.vercel.app/docs/environments/server-client-components#async-components`, {
+        cause: error
+      });
+    } else {
+      throw error;
+    }
+  }
+}
+function useConfig(hookName) {
+  return useHook(hookName, getConfig());
+}
+
+export { useConfig as default };

package/dist/esm/development/react-server/useFormatter.js

@@ -0,0 +1,9 @@
+import getFormatterCached from '../server/react-server/getServerFormatter.js';
+import useConfig from './useConfig.js';
+
+function useFormatter() {
+  const config = useConfig('useFormatter');
+  return getFormatterCached(config);
+}
+
+export { useFormatter as default };

package/dist/esm/development/react-server/useLocale.js

@@ -0,0 +1,8 @@
+import useConfig from './useConfig.js';
+
+function useLocale() {
+  const config = useConfig('useLocale');
+  return config.locale;
+}
+
+export { useLocale as default };

package/dist/esm/development/react-server/useMessages.js

@@ -0,0 +1,9 @@
+import { getMessagesFromConfig } from '../server/react-server/getMessages.js';
+import useConfig from './useConfig.js';
+
+function useMessages() {
+  const config = useConfig('useMessages');
+  return getMessagesFromConfig(config);
+}
+
+export { useMessages as default };

package/dist/esm/development/react-server/useNow.js

@@ -0,0 +1,12 @@
+import getDefaultNow from '../server/react-server/getDefaultNow.js';
+import useConfig from './useConfig.js';
+
+function useNow(options) {
+  if (options?.updateInterval != null) {
+    console.error("`useNow` doesn't support the `updateInterval` option in Server Components, the value will be ignored. If you need the value to update, you can convert the component to a Client Component.");
+  }
+  const config = useConfig('useNow');
+  return config.now ?? getDefaultNow();
+}
+
+export { useNow as default };

package/dist/esm/development/react-server/useTimeZone.js

@@ -0,0 +1,8 @@
+import useConfig from './useConfig.js';
+
+function useTimeZone() {
+  const config = useConfig('useTimeZone');
+  return config.timeZone;
+}
+
+export { useTimeZone as default };

package/dist/esm/development/react-server/useTranslations.js

@@ -0,0 +1,9 @@
+import getServerTranslator from '../server/react-server/getServerTranslator.js';
+import useConfig from './useConfig.js';
+
+function useTranslations(...[namespace]) {
+  const config = useConfig('useTranslations');
+  return getServerTranslator(config, namespace);
+}
+
+export { useTranslations as default };

package/dist/esm/development/routing/config.js

@@ -0,0 +1,28 @@
+function receiveRoutingConfig(input) {
+  return {
+    ...input,
+    localePrefix: receiveLocalePrefixConfig(input.localePrefix),
+    localeCookie: receiveLocaleCookie(input.localeCookie),
+    localeDetection: input.localeDetection ?? true,
+    alternateLinks: input.alternateLinks ?? true
+  };
+}
+function receiveLocaleCookie(localeCookie) {
+  return localeCookie ?? true ? {
+    name: 'NEXT_LOCALE',
+    maxAge: 5 * 60 * 60,
+    // 5 hours
+    sameSite: 'lax',
+    ...(typeof localeCookie === 'object' && localeCookie)
+
+    // `path` needs to be provided based on a detected base path
+    // that depends on the environment when setting a cookie
+  } : false;
+}
+function receiveLocalePrefixConfig(localePrefix) {
+  return typeof localePrefix === 'object' ? localePrefix : {
+    mode: localePrefix || 'always'
+  };
+}
+
+export { receiveRoutingConfig };

package/dist/esm/development/routing/defineRouting.js

@@ -0,0 +1,5 @@
+function defineRouting(config) {
+  return config;
+}
+
+export { defineRouting as default };

package/dist/esm/development/routing.js

@@ -0,0 +1 @@
+export { default as defineRouting } from './routing/defineRouting.js';

package/dist/{development → esm/development}/server/react-client/index.js

@@ -1,7 +1,3 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
 /**
  * Allows to import `next-intl/server` in non-RSC environments.
  *
@@ -12,10 +8,12 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 function notSupported(message) {
   return () => {
-    throw new Error("`".concat(message, "` is not supported in Client Components."));
+    throw new Error(`\`${message}\` is not supported in Client Components.`);
   };
 }
-function getRequestConfig() {
+function getRequestConfig(
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+...args) {
   return notSupported('getRequestConfig');
 }
 const getFormatter = notSupported('getFormatter');
@@ -28,15 +26,6 @@ const getLocale = notSupported('getLocale');
 // causes a type error. The types use the `react-server` entry
 // anyway, therefore this is irrelevant.
 const getTranslations = notSupported('getTranslations');
-const unstable_setRequestLocale = notSupported('unstable_setRequestLocale');
 const setRequestLocale = notSupported('setRequestLocale');
 
-exports.getFormatter = getFormatter;
-exports.getLocale = getLocale;
-exports.getMessages = getMessages;
-exports.getNow = getNow;
-exports.getRequestConfig = getRequestConfig;
-exports.getTimeZone = getTimeZone;
-exports.getTranslations = getTranslations;
-exports.setRequestLocale = setRequestLocale;
-exports.unstable_setRequestLocale = unstable_setRequestLocale;
+export { getFormatter, getLocale, getMessages, getNow, getRequestConfig, getTimeZone, getTranslations, setRequestLocale };

package/dist/{development → esm/development}/server/react-server/RequestLocale.js

@@ -1,23 +1,19 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var headers = require('next/headers');
-var React = require('react');
-var constants = require('../../shared/constants.js');
-var RequestLocaleCache = require('./RequestLocaleCache.js');
+import { headers } from 'next/headers.js';
+import { cache } from 'react';
+import { HEADER_LOCALE_NAME } from '../../shared/constants.js';
+import { getCachedRequestLocale } from './RequestLocaleCache.js';
 
 async function getHeadersImpl() {
-  const promiseOrValue = headers.headers();
+  const promiseOrValue = headers();
 
   // Compatibility with Next.js <15
   return promiseOrValue instanceof Promise ? await promiseOrValue : promiseOrValue;
 }
-const getHeaders = React.cache(getHeadersImpl);
+const getHeaders = cache(getHeadersImpl);
 async function getLocaleFromHeaderImpl() {
   let locale;
   try {
-    locale = (await getHeaders()).get(constants.HEADER_LOCALE_NAME) || undefined;
+    locale = (await getHeaders()).get(HEADER_LOCALE_NAME) || undefined;
   } catch (error) {
     if (error instanceof Error && error.digest === 'DYNAMIC_SERVER_USAGE') {
       const wrappedError = new Error('Usage of next-intl APIs in Server Components currently opts into dynamic rendering. This limitation will eventually be lifted, but as a stopgap solution, you can use the `setRequestLocale` API to enable static rendering, see https://next-intl-docs.vercel.app/docs/getting-started/app-router/with-i18n-routing#static-rendering', {
@@ -31,9 +27,9 @@ async function getLocaleFromHeaderImpl() {
   }
   return locale;
 }
-const getLocaleFromHeader = React.cache(getLocaleFromHeaderImpl);
+const getLocaleFromHeader = cache(getLocaleFromHeaderImpl);
 async function getRequestLocale() {
-  return RequestLocaleCache.getCachedRequestLocale() || (await getLocaleFromHeader());
+  return getCachedRequestLocale() || (await getLocaleFromHeader());
 }
 
-exports.getRequestLocale = getRequestLocale;
+export { getRequestLocale };

package/dist/{development → esm/development}/server/react-server/RequestLocaleCache.js

@@ -1,8 +1,4 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var React = require('react');
+import { cache } from 'react';
 
 // See https://github.com/vercel/next.js/discussions/58862
 function getCacheImpl() {
@@ -11,7 +7,7 @@ function getCacheImpl() {
   };
   return value;
 }
-const getCache = React.cache(getCacheImpl);
+const getCache = cache(getCacheImpl);
 function getCachedRequestLocale() {
   return getCache().locale;
 }
@@ -19,5 +15,4 @@ function setCachedRequestLocale(locale) {
   getCache().locale = locale;
 }
 
-exports.getCachedRequestLocale = getCachedRequestLocale;
-exports.setCachedRequestLocale = setCachedRequestLocale;
+export { getCachedRequestLocale, setCachedRequestLocale };

package/dist/esm/development/server/react-server/createRequestConfig.js

@@ -0,0 +1,2 @@
+import getRuntimeConfig from 'next-intl/config';
+export { default } from 'next-intl/config';