next-intl 3.21.1 → 3.21.2-canary.0

package/dist/development/navigation/shared/LegacyBaseLink.js

@@ -0,0 +1,57 @@
+"use client";
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.js');
+var navigation = require('next/navigation');
+var React = require('react');
+var useLocale = require('../../react-client/useLocale.js');
+var utils = require('../../shared/utils.js');
+var BaseLink = require('./BaseLink.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+function LegacyBaseLink(_ref, ref) {
+  let {
+    href,
+    locale,
+    localeCookie,
+    localePrefixMode,
+    prefix,
+    ...rest
+  } = _ref;
+  // The types aren't entirely correct here. Outside of Next.js
+  // `useParams` can be called, but the return type is `null`.
+  const pathname = navigation.usePathname();
+  const curLocale = useLocale.default();
+  const isChangingLocale = locale !== curLocale;
+  const [localizedHref, setLocalizedHref] = React.useState(() => utils.isLocalizableHref(href) && (localePrefixMode !== 'never' || isChangingLocale) ?
+  // For the `localePrefix: 'as-needed' strategy, the href shouldn't
+  // be prefixed if the locale is the default locale. To determine this, we
+  // need a) the default locale and b) the information if we use prefixed
+  // routing. The default locale can vary by domain, therefore during the
+  // RSC as well as the SSR render, we can't determine the default locale
+  // statically. Therefore we always prefix the href since this will
+  // always result in a valid URL, even if it might cause a redirect. This
+  // is better than pointing to a non-localized href during the server
+  // render, which would potentially be wrong. The final href is
+  // determined in the effect below.
+  utils.prefixHref(href, prefix) : href);
+  React.useEffect(() => {
+    if (!pathname) return;
+    setLocalizedHref(utils.localizeHref(href, locale, curLocale, pathname, prefix));
+  }, [curLocale, href, locale, pathname, prefix]);
+  return /*#__PURE__*/React__default.default.createElement(BaseLink.default, _rollupPluginBabelHelpers.extends({
+    ref: ref,
+    href: localizedHref,
+    locale: locale,
+    localeCookie: localeCookie
+  }, rest));
+}
+const LegacyBaseLinkWithRef = /*#__PURE__*/React.forwardRef(LegacyBaseLink);
+LegacyBaseLinkWithRef.displayName = 'ClientLink';
+
+exports.default = LegacyBaseLinkWithRef;

package/dist/development/navigation/shared/createSharedNavigationFns.js

@@ -0,0 +1,148 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.js');
+var navigation = require('next/navigation');
+var React = require('react');
+var config = require('../../routing/config.js');
+var utils$1 = require('../../shared/utils.js');
+var BaseLink = require('./BaseLink.js');
+var utils = require('./utils.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+/**
+ * Shared implementations for `react-server` and `react-client`
+ */
+function createSharedNavigationFns(getLocale, routing) {
+  const config$1 = config.receiveRoutingConfig(routing || {});
+  {
+    utils.validateReceivedConfig(config$1);
+  }
+  const pathnames = config$1.pathnames;
+
+  // This combination requires that the current host is known in order to
+  // compute a correct pathname. Since that can only be achieved by reading from
+  // headers, this would break static rendering. Therefore, as a workaround we
+  // always add a prefix in this case to be on the safe side. The downside is
+  // that the user might get redirected again if the middleware detects that the
+  // prefix is not needed.
+  const forcePrefixSsr = config$1.localePrefix.mode === 'as-needed' && config$1.domains || undefined;
+  function Link(_ref, ref) {
+    let {
+      href,
+      locale,
+      ...rest
+    } = _ref;
+    let pathname, params;
+    if (typeof href === 'object') {
+      pathname = href.pathname;
+      // @ts-expect-error -- This is ok
+      params = href.params;
+    } else {
+      pathname = href;
+    }
+
+    // @ts-expect-error -- This is ok
+    const isLocalizable = utils$1.isLocalizableHref(href);
+    const localePromiseOrValue = getLocale();
+    const curLocale = localePromiseOrValue instanceof Promise ? React.use(localePromiseOrValue) : localePromiseOrValue;
+    const finalPathname = isLocalizable ? getPathname(
+    // @ts-expect-error -- This is ok
+    {
+      locale: locale || curLocale,
+      href: pathnames == null ? pathname : {
+        pathname,
+        params
+      }
+    }, locale != null || forcePrefixSsr || undefined) : pathname;
+    return /*#__PURE__*/React__default.default.createElement(BaseLink.default, _rollupPluginBabelHelpers.extends({
+      ref: ref
+      // @ts-expect-error -- Available after the validation
+      ,
+      defaultLocale: config$1.defaultLocale,
+      href: {
+        ...(typeof href === 'object' && href),
+        // @ts-expect-error -- This is ok
+        pathname: finalPathname
+      },
+      locale: locale,
+      localeCookie: config$1.localeCookie
+      // Provide the minimal relevant information to the client side in order
+      // to potentially remove the prefix in case of the `forcePrefixSsr` case
+      ,
+      unprefixed: forcePrefixSsr && isLocalizable ? {
+        domains: config$1.domains.reduce((acc, domain) => {
+          // @ts-expect-error -- This is ok
+          acc[domain.domain] = domain.defaultLocale;
+          return acc;
+        }, {}),
+        pathname: getPathname(
+        // @ts-expect-error -- This is ok
+        {
+          locale: curLocale,
+          href: pathnames == null ? pathname : {
+            pathname,
+            params
+          }
+        }, false)
+      } : undefined
+    }, rest));
+  }
+  const LinkWithRef = /*#__PURE__*/React.forwardRef(Link);
+  function getPathname(args, /** @private Removed in types returned below */
+  _forcePrefix) {
+    const {
+      href,
+      locale
+    } = args;
+    let pathname;
+    if (pathnames == null) {
+      if (typeof href === 'object') {
+        pathname = href.pathname;
+        if (href.query) {
+          pathname += utils.serializeSearchParams(href.query);
+        }
+      } else {
+        pathname = href;
+      }
+    } else {
+      pathname = utils.compileLocalizedPathname({
+        locale,
+        // @ts-expect-error -- This is ok
+        ...utils.normalizeNameOrNameWithParams(href),
+        // @ts-expect-error -- This is ok
+        pathnames: config$1.pathnames
+      });
+    }
+    return utils.applyPathnamePrefix(pathname, locale, config$1,
+    // @ts-expect-error -- This is ok
+    args.domain, _forcePrefix);
+  }
+  function getRedirectFn(fn) {
+    /** @see https://next-intl-docs.vercel.app/docs/routing/navigation#redirect */
+    return function redirectFn(args) {
+      for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        rest[_key - 1] = arguments[_key];
+      }
+      return fn(
+      // @ts-expect-error -- We're forcing the prefix when no domain is provided
+      getPathname(args, args.domain ? undefined : forcePrefixSsr), ...rest);
+    };
+  }
+  const redirect = getRedirectFn(navigation.redirect);
+  const permanentRedirect = getRedirectFn(navigation.permanentRedirect);
+  return {
+    config: config$1,
+    Link: LinkWithRef,
+    redirect,
+    permanentRedirect,
+    // Remove `_forcePrefix` from public API
+    getPathname: getPathname
+  };
+}
+
+exports.default = createSharedNavigationFns;

package/dist/development/navigation/shared/redirects.js

@@ -8,6 +8,9 @@ var utils = require('../../shared/utils.js');
 function createRedirectFn(redirectFn) {
   return function baseRedirect(params) {
     const prefix = utils.getLocalePrefix(params.locale, params.localePrefix);
+
+    // This logic is considered legacy and is replaced by `applyPathnamePrefix`.
+    // We keep it this way for now for backwards compatibility.
     const localizedPathname = params.localePrefix.mode === 'never' || !utils.isLocalizableHref(params.pathname) ? params.pathname : utils.prefixPathname(prefix, params.pathname);
     for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
       args[_key - 1] = arguments[_key];

package/dist/development/navigation/shared/syncLocaleCookie.js

@@ -2,7 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var constants = require('../../shared/constants.js');
 var utils = require('./utils.js');
 
 /**
@@ -10,9 +9,9 @@ var utils = require('./utils.js');
  * skip a request to the server due to its router cache.
  * See https://github.com/amannn/next-intl/issues/786.
  */
-function syncLocaleCookie(pathname, locale, nextLocale) {
+function syncLocaleCookie(localeCookie, pathname, locale, nextLocale) {
   const isSwitchingLocale = nextLocale !== locale && nextLocale != null;
-  if (!isSwitchingLocale ||
+  if (!localeCookie || !isSwitchingLocale ||
   // Theoretical case, we always have a pathname in a real app,
   // only not when running e.g. in a simulated test environment
   !pathname) {
@@ -20,11 +19,33 @@ function syncLocaleCookie(pathname, locale, nextLocale) {
   }
   const basePath = utils.getBasePath(pathname);
   const hasBasePath = basePath !== '';
-  const path = hasBasePath ? basePath : '/';
+  const defaultPath = hasBasePath ? basePath : '/';
+  const {
+    name,
+    ...rest
+  } = localeCookie;
+  if (!rest.path) {
+    rest.path = defaultPath;
+  }
+  let localeCookieString = "".concat(name, "=").concat(nextLocale, ";");
+  for (const [key, value] of Object.entries(rest)) {
+    // Map object properties to cookie properties.
+    // Interestingly, `maxAge` corresponds to `max-age`,
+    // while `sameSite` corresponds to `SameSite`.
+    // Also, keys are case-insensitive.
+    const targetKey = key === 'maxAge' ? 'max-age' : key;
+    localeCookieString += "".concat(targetKey);
+    if (typeof value !== 'boolean') {
+      localeCookieString += '=' + value;
+    }
+
+    // A trailing ";" is allowed by browsers
+    localeCookieString += ';';
+  }
 
   // Note that writing to `document.cookie` doesn't overwrite all
   // cookies, but only the ones referenced via the name here.
-  document.cookie = "".concat(constants.COOKIE_LOCALE_NAME, "=").concat(nextLocale, "; path=").concat(path, "; max-age=").concat(constants.COOKIE_MAX_AGE, "; sameSite=").concat(constants.COOKIE_SAME_SITE);
+  document.cookie = localeCookieString;
 }
 
 exports.default = syncLocaleCookie;

package/dist/development/navigation/shared/utils.js

@@ -7,8 +7,11 @@ var utils = require('../../shared/utils.js');
 // Minor false positive: A route that has both optional and
 // required params will allow optional params.
 
+// For `Link`
+
+// For `getPathname` (hence also its consumers: `redirect`, `useRouter`, …)
+
 function normalizeNameOrNameWithParams(href) {
-  // @ts-expect-error -- `extends string` in the generic unfortunately weakens the type
   return typeof href === 'string' ? {
     pathname: href
   } : href;
@@ -40,6 +43,7 @@ function compileLocalizedPathname(_ref) {
   function getNamedPath(value) {
     let namedPath = pathnames[value];
     if (!namedPath) {
+      // Unknown pathnames
       namedPath = value;
     }
     return namedPath;
@@ -118,9 +122,44 @@ function getBasePath(pathname) {
     return windowPathname.replace(pathname, '');
   }
 }
+function applyPathnamePrefix(pathname, locale, routing, domain, force) {
+  const {
+    mode
+  } = routing.localePrefix;
+  let shouldPrefix;
+  if (force !== undefined) {
+    shouldPrefix = force;
+  } else if (utils.isLocalizableHref(pathname)) {
+    if (mode === 'always') {
+      shouldPrefix = true;
+    } else if (mode === 'as-needed') {
+      let defaultLocale = routing.defaultLocale;
+      if (routing.domains) {
+        const domainConfig = routing.domains.find(cur => cur.domain === domain);
+        if (domainConfig) {
+          defaultLocale = domainConfig.defaultLocale;
+        } else {
+          if (!domain) {
+            console.error("You're using a routing configuration with `localePrefix: 'as-needed'` in combination with `domains`. In order to compute a correct pathname, you need to provide a `domain` parameter.\n\nSee: https://next-intl-docs.vercel.app/docs/routing#domains-localeprefix-asneeded");
+          }
+        }
+      }
+      shouldPrefix = defaultLocale !== locale;
+    }
+  }
+  return shouldPrefix ? utils.prefixPathname(utils.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)) {
+    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;

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

@@ -4,8 +4,10 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var createSharedPathnamesNavigation = require('./navigation/react-client/createSharedPathnamesNavigation.js');
 var createLocalizedPathnamesNavigation = require('./navigation/react-client/createLocalizedPathnamesNavigation.js');
+var createNavigation = require('./navigation/react-client/createNavigation.js');
 
 
 
 exports.createSharedPathnamesNavigation = createSharedPathnamesNavigation.default;
 exports.createLocalizedPathnamesNavigation = createLocalizedPathnamesNavigation.default;
+exports.createNavigation = createNavigation.default;

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

@@ -4,8 +4,10 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var createSharedPathnamesNavigation = require('./navigation/react-server/createSharedPathnamesNavigation.js');
 var createLocalizedPathnamesNavigation = require('./navigation/react-server/createLocalizedPathnamesNavigation.js');
+var createNavigation = require('./navigation/react-server/createNavigation.js');
 
 
 
 exports.createSharedPathnamesNavigation = createSharedPathnamesNavigation.default;
 exports.createLocalizedPathnamesNavigation = createLocalizedPathnamesNavigation.default;
+exports.createNavigation = createNavigation.default;

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

@@ -14,8 +14,6 @@ var useIntl = require('use-intl');
  *   supported in all Next.js versions that are supported.
  */
 
-
-// eslint-disable-next-line @typescript-eslint/ban-types
 function callHook(name, hook) {
   return function () {
     try {

package/dist/development/routing/config.js

@@ -3,16 +3,33 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function receiveRoutingConfig(input) {
+  var _input$localeDetectio, _input$alternateLinks;
   return {
     ...input,
-    localePrefix: receiveLocalePrefixConfig(input.localePrefix)
+    localePrefix: receiveLocalePrefixConfig(input === null || input === void 0 ? void 0 : input.localePrefix),
+    localeCookie: receiveLocaleCookie(input.localeCookie),
+    localeDetection: (_input$localeDetectio = input.localeDetection) !== null && _input$localeDetectio !== void 0 ? _input$localeDetectio : true,
+    alternateLinks: (_input$alternateLinks = input.alternateLinks) !== null && _input$alternateLinks !== void 0 ? _input$alternateLinks : true
   };
 }
+function receiveLocaleCookie(localeCookie) {
+  return (localeCookie !== null && localeCookie !== void 0 ? localeCookie : true) ? {
+    name: 'NEXT_LOCALE',
+    maxAge: 31536000,
+    // 1 year
+    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'
   };
 }
 
+exports.receiveLocaleCookie = receiveLocaleCookie;
 exports.receiveLocalePrefixConfig = receiveLocalePrefixConfig;
 exports.receiveRoutingConfig = receiveRoutingConfig;

package/dist/development/server/react-server/RequestLocale.js

@@ -3,47 +3,37 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var headers = require('next/headers');
-var navigation = require('next/navigation');
 var React = require('react');
 var constants = require('../../shared/constants.js');
+var RequestLocaleCache = require('./RequestLocaleCache.js');
 
-function getLocaleFromHeaderImpl() {
+async function getHeadersImpl() {
+  const promiseOrValue = headers.headers();
+
+  // Compatibility with Next.js <15
+  return promiseOrValue instanceof Promise ? await promiseOrValue : promiseOrValue;
+}
+const getHeaders = React.cache(getHeadersImpl);
+async function getLocaleFromHeaderImpl() {
   let locale;
   try {
-    locale = headers.headers().get(constants.HEADER_LOCALE_NAME);
+    locale = (await getHeaders()).get(constants.HEADER_LOCALE_NAME) || undefined;
   } catch (error) {
     if (error instanceof Error && error.digest === 'DYNAMIC_SERVER_USAGE') {
-      throw 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 `unstable_setRequestLocale` API to enable static rendering, see https://next-intl-docs.vercel.app/docs/getting-started/app-router/with-i18n-routing#static-rendering', {
+      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 `unstable_setRequestLocale` API to enable static rendering, see https://next-intl-docs.vercel.app/docs/getting-started/app-router/with-i18n-routing#static-rendering', {
         cause: error
       });
+      wrappedError.digest = error.digest;
+      throw wrappedError;
     } else {
       throw error;
     }
   }
-  if (!locale) {
-    {
-      console.error("\nUnable to find `next-intl` locale because the middleware didn't run on this request. See https://next-intl-docs.vercel.app/docs/routing/middleware#unable-to-find-locale. The `notFound()` function will be called as a result.\n");
-    }
-    navigation.notFound();
-  }
   return locale;
 }
 const getLocaleFromHeader = React.cache(getLocaleFromHeaderImpl);
-
-// Workaround until `createServerContext` is available
-function getCacheImpl() {
-  const value = {
-    locale: undefined
-  };
-  return value;
-}
-const getCache = React.cache(getCacheImpl);
-function setRequestLocale(locale) {
-  getCache().locale = locale;
-}
-function getRequestLocale() {
-  return getCache().locale || getLocaleFromHeader();
+async function getRequestLocale() {
+  return RequestLocaleCache.getCachedRequestLocale() || (await getLocaleFromHeader());
 }
 
 exports.getRequestLocale = getRequestLocale;
-exports.setRequestLocale = setRequestLocale;

package/dist/development/server/react-server/RequestLocaleCache.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+// See https://github.com/vercel/next.js/discussions/58862
+function getCacheImpl() {
+  const value = {
+    locale: undefined
+  };
+  return value;
+}
+const getCache = React.cache(getCacheImpl);
+function getCachedRequestLocale() {
+  return getCache().locale;
+}
+function setCachedRequestLocale(locale) {
+  getCache().locale = locale;
+}
+
+exports.getCachedRequestLocale = getCachedRequestLocale;
+exports.setCachedRequestLocale = setCachedRequestLocale;

package/dist/development/server/react-server/RequestLocaleLegacy.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var headers = require('next/headers');
+var navigation = require('next/navigation');
+var React = require('react');
+var constants = require('../../shared/constants.js');
+var RequestLocaleCache = require('./RequestLocaleCache.js');
+
+// This was originally built for Next.js <14, where `headers()` was not async.
+// With https://github.com/vercel/next.js/pull/68812, the API became async.
+// This file can be removed once we remove the legacy navigation APIs.
+function getHeaders() {
+  return headers.headers();
+}
+function getLocaleFromHeaderImpl() {
+  let locale;
+  try {
+    locale = getHeaders().get(constants.HEADER_LOCALE_NAME);
+  } catch (error) {
+    if (error instanceof Error && error.digest === 'DYNAMIC_SERVER_USAGE') {
+      throw 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 `unstable_setRequestLocale` API to enable static rendering, see https://next-intl-docs.vercel.app/docs/getting-started/app-router/with-i18n-routing#static-rendering', {
+        cause: error
+      });
+    } else {
+      throw error;
+    }
+  }
+  if (!locale) {
+    {
+      console.error("\nUnable to find `next-intl` locale because the middleware didn't run on this request. See https://next-intl-docs.vercel.app/docs/routing/middleware#unable-to-find-locale. The `notFound()` function will be called as a result.\n");
+    }
+    navigation.notFound();
+  }
+  return locale;
+}
+const getLocaleFromHeader = React.cache(getLocaleFromHeaderImpl);
+function getRequestLocale() {
+  return RequestLocaleCache.getCachedRequestLocale() || getLocaleFromHeader();
+}
+
+exports.getRequestLocale = getRequestLocale;

package/dist/development/server/react-server/getConfig.js

@@ -2,9 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var navigation = require('next/navigation');
 var React = require('react');
 var core = require('use-intl/core');
 var RequestLocale = require('./RequestLocale.js');
+var RequestLocaleLegacy = require('./RequestLocaleLegacy.js');
 var getRuntimeConfig = require('next-intl/config');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -27,35 +29,31 @@ async function receiveRuntimeConfigImpl(getConfig, localeOverride) {
   if (typeof getConfig !== 'function') {
     throw new Error("Invalid i18n request configuration detected.\n\nPlease verify that:\n1. In case you've specified a custom location in your Next.js config, make sure that the path is correct.\n2. You have a default export in your i18n request configuration file.\n\nSee also: https://next-intl-docs.vercel.app/docs/usage/configuration#i18n-request\n");
   }
-  let hasReadLocale = false;
-
-  // In case the consumer doesn't read `params.locale` and instead provides the
-  // `locale` (either in a single-language workflow or because the locale is
-  // read from the user settings), don't attempt to read the request locale.
   const params = {
+    // In case the consumer doesn't read `params.locale` and instead provides the
+    // `locale` (either in a single-language workflow or because the locale is
+    // read from the user settings), don't attempt to read the request locale.
     get locale() {
-      hasReadLocale = true;
-      return localeOverride || RequestLocale.getRequestLocale();
+      return localeOverride || RequestLocaleLegacy.getRequestLocale();
+    },
+    get requestLocale() {
+      return localeOverride ? Promise.resolve(localeOverride) : RequestLocale.getRequestLocale();
     }
   };
   let result = getConfig(params);
   if (result instanceof Promise) {
     result = await result;
   }
-  {
-    if (hasReadLocale) {
-      if (result.locale) {
-        console.error("\nYou've read the `locale` param that was passed to `getRequestConfig` but have also returned one from the function. This is likely an error, please ensure that you're consistently using a setup with or without i18n routing: https://next-intl-docs.vercel.app/docs/getting-started/app-router\n");
-      }
-    } else {
-      if (!result.locale) {
-        console.error("\nYou haven't read the `locale` param that was passed to `getRequestConfig` and also haven't returned one from the function. This is likely an error, please ensure that you're consistently using a setup with or without i18n routing: https://next-intl-docs.vercel.app/docs/getting-started/app-router\n");
-      }
+  const locale = result.locale || (await params.requestLocale);
+  if (!locale) {
+    {
+      console.error("\nUnable to find `next-intl` locale because the middleware didn't run on this request and no `locale` was returned in `getRequestConfig`. See https://next-intl-docs.vercel.app/docs/routing/middleware#unable-to-find-locale. The `notFound()` function will be called as a result.\n");
     }
+    navigation.notFound();
   }
   return {
     ...result,
-    locale: result.locale || params.locale,
+    locale,
     now: result.now || getDefaultNow(),
     timeZone: result.timeZone || getDefaultTimeZone()
   };

package/dist/development/server/react-server/getRequestConfig.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 /**
- * Should be called in `i18n.ts` to create the configuration for the current request.
+ * Should be called in `i18n/request.ts` to create the configuration for the current request.
  */
 function getRequestConfig(createRequestConfig) {
   return createRequestConfig;

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

@@ -9,7 +9,7 @@ var getNow = require('./server/react-server/getNow.js');
 var getTimeZone = require('./server/react-server/getTimeZone.js');
 var getTranslations = require('./server/react-server/getTranslations.js');
 var getLocale = require('./server/react-server/getLocale.js');
-var RequestLocale = require('./server/react-server/RequestLocale.js');
+var RequestLocaleCache = require('./server/react-server/RequestLocaleCache.js');
 
 
 
@@ -20,4 +20,4 @@ exports.getNow = getNow.default;
 exports.getTimeZone = getTimeZone.default;
 exports.getTranslations = getTranslations.default;
 exports.getLocale = getLocale.default;
-exports.unstable_setRequestLocale = RequestLocale.setRequestLocale;
+exports.unstable_setRequestLocale = RequestLocaleCache.setCachedRequestLocale;

package/dist/development/shared/constants.js

@@ -2,20 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-// Reuse the legacy cookie name
-// https://nextjs.org/docs/advanced-features/i18n-routing#leveraging-the-next_locale-cookie
-const COOKIE_LOCALE_NAME = 'NEXT_LOCALE';
-const COOKIE_MAX_AGE = 31536000; // 1 year
-const COOKIE_SAME_SITE = 'lax';
-
 // Should take precedence over the cookie
 const HEADER_LOCALE_NAME = 'X-NEXT-INTL-LOCALE';
 
 // In a URL like "/en-US/about", the locale segment is "en-US"
 const LOCALE_SEGMENT_NAME = 'locale';
 
-exports.COOKIE_LOCALE_NAME = COOKIE_LOCALE_NAME;
-exports.COOKIE_MAX_AGE = COOKIE_MAX_AGE;
-exports.COOKIE_SAME_SITE = COOKIE_SAME_SITE;
 exports.HEADER_LOCALE_NAME = HEADER_LOCALE_NAME;
 exports.LOCALE_SEGMENT_NAME = LOCALE_SEGMENT_NAME;