next-intl 3.20.0 → 3.21.0-canary.0

package/dist/development/middleware/middleware.js

@@ -55,7 +55,7 @@ function createMiddleware(routing, options) {
     }
     function redirect(url, redirectDomain) {
       const urlObj = new URL(utils$1.normalizeTrailingSlash(url), request.url);
-      if (domainsConfig.length > 0 && !redirectDomain) {
+      if (domainsConfig.length > 0 && !redirectDomain && domain) {
         const bestMatchingDomain = utils.getBestMatchingDomain(domain, locale, domainsConfig);
         if (bestMatchingDomain) {
           redirectDomain = bestMatchingDomain.domain;
@@ -84,11 +84,12 @@ function createMiddleware(routing, options) {
     let response;
     let internalTemplateName;
     let unprefixedInternalPathname = unprefixedExternalPathname;
-    if ('pathnames' in resolvedRouting) {
+    const pathnames = resolvedRouting.pathnames;
+    if (pathnames) {
       let resolvedTemplateLocale;
-      [resolvedTemplateLocale, internalTemplateName] = utils.getInternalTemplate(resolvedRouting.pathnames, unprefixedExternalPathname, locale);
+      [resolvedTemplateLocale, internalTemplateName] = utils.getInternalTemplate(pathnames, unprefixedExternalPathname, locale);
       if (internalTemplateName) {
-        const pathnameConfig = resolvedRouting.pathnames[internalTemplateName];
+        const pathnameConfig = pathnames[internalTemplateName];
         const localeTemplate = typeof pathnameConfig === 'string' ? pathnameConfig :
         // @ts-expect-error -- This is fine
         pathnameConfig[locale];
@@ -156,10 +157,9 @@ function createMiddleware(routing, options) {
       syncCookie.default(request, response, locale);
     }
     if (resolvedRouting.localePrefix.mode !== 'never' && resolvedOptions.alternateLinks && resolvedRouting.locales.length > 1) {
-      var _resolvedRouting$path;
       response.headers.set('Link', getAlternateLinksHeaderValue.default({
         routing: resolvedRouting,
-        localizedPathnames: internalTemplateName != null && 'pathnames' in resolvedRouting ? (_resolvedRouting$path = resolvedRouting.pathnames) === null || _resolvedRouting$path === void 0 ? void 0 : _resolvedRouting$path[internalTemplateName] : undefined,
+        localizedPathnames: internalTemplateName != null && pathnames ? pathnames === null || pathnames === void 0 ? void 0 : pathnames[internalTemplateName] : undefined,
         request,
         resolvedLocale: locale
       }));

package/dist/development/middleware/resolveLocale.js

@@ -12,11 +12,7 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var Negotiator__default = /*#__PURE__*/_interopDefault(Negotiator);
 
 function findDomainFromHost(requestHeaders, domains) {
-  var _host;
-  let host = utils.getHost(requestHeaders);
-
-  // Remove port (easier for local development)
-  host = (_host = host) === null || _host === void 0 ? void 0 : _host.replace(/:\d+$/, '');
+  const host = utils.getHost(requestHeaders);
   if (host && domains) {
     return domains.find(cur => cur.domain === host);
   }
@@ -139,8 +135,7 @@ function resolveLocaleFromDomain(routing, options, requestHeaders, requestCookie
 }
 function resolveLocale(routing, options, requestHeaders, requestCookies, pathname) {
   if (routing.domains) {
-    const routingWithDomains = routing;
-    return resolveLocaleFromDomain(routingWithDomains, options, requestHeaders, requestCookies, pathname);
+    return resolveLocaleFromDomain(routing, options, requestHeaders, requestCookies, pathname);
   } else {
     return {
       locale: resolveLocaleFromPrefix(routing, options, requestHeaders, requestCookies, pathname)

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

@@ -6,7 +6,7 @@ var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelper
 var React = require('react');
 var useLocale = require('../../react-client/useLocale.js');
 var utils = require('../../shared/utils.js');
-var BaseLink = require('../shared/BaseLink.js');
+var LegacyBaseLink = require('../shared/LegacyBaseLink.js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -21,7 +21,7 @@ function ClientLink(_ref, ref) {
   const defaultLocale = useLocale.default();
   const finalLocale = locale || defaultLocale;
   const prefix = utils.getLocalePrefix(finalLocale, localePrefix);
-  return /*#__PURE__*/React__default.default.createElement(BaseLink.default, _rollupPluginBabelHelpers.extends({
+  return /*#__PURE__*/React__default.default.createElement(LegacyBaseLink.default, _rollupPluginBabelHelpers.extends({
     ref: ref,
     locale: finalLocale,
     localePrefixMode: localePrefix.mode,

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

@@ -0,0 +1,83 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var navigation = require('next/navigation');
+var React = require('react');
+var useLocale = require('../../react-client/useLocale.js');
+var createSharedNavigationFns = require('../shared/createSharedNavigationFns.js');
+var syncLocaleCookie = require('../shared/syncLocaleCookie.js');
+var utils = require('../shared/utils.js');
+var useBasePathname = require('./useBasePathname.js');
+
+function createNavigation(routing) {
+  function useTypedLocale() {
+    return useLocale.default();
+  }
+  const {
+    Link,
+    config,
+    getPathname,
+    ...redirects
+  } = createSharedNavigationFns.default(useTypedLocale, routing);
+
+  /** @see https://next-intl-docs.vercel.app/docs/routing/navigation#usepathname */
+  function usePathname() {
+    const pathname = useBasePathname.default(config.localePrefix);
+    const locale = useTypedLocale();
+
+    // @ts-expect-error -- Mirror the behavior from Next.js, where `null` is returned when `usePathname` is used outside of Next, but the types indicate that a string is always returned.
+    return React.useMemo(() => pathname &&
+    // @ts-expect-error -- This is fine
+    config.pathnames ? utils.getRoute(locale, pathname,
+    // @ts-expect-error -- This is fine
+    config.pathnames) : pathname, [locale, pathname]);
+  }
+  function useRouter() {
+    const router = navigation.useRouter();
+    const curLocale = useTypedLocale();
+    const nextPathname = navigation.usePathname();
+    return React.useMemo(() => {
+      function createHandler(fn) {
+        return function handler(href, options) {
+          const {
+            locale: nextLocale,
+            ...rest
+          } = options || {};
+
+          // @ts-expect-error -- We're passing a domain here just in case
+          const pathname = getPathname({
+            href,
+            locale: nextLocale || curLocale,
+            domain: window.location.host
+          });
+          const args = [pathname];
+          if (Object.keys(rest).length > 0) {
+            // @ts-expect-error -- This is fine
+            args.push(rest);
+          }
+          fn(...args);
+          syncLocaleCookie.default(nextPathname, curLocale, nextLocale);
+        };
+      }
+      return {
+        ...router,
+        /** @see https://next-intl-docs.vercel.app/docs/routing/navigation#userouter */
+        push: createHandler(router.push),
+        /** @see https://next-intl-docs.vercel.app/docs/routing/navigation#userouter */
+        replace: createHandler(router.replace),
+        /** @see https://next-intl-docs.vercel.app/docs/routing/navigation#userouter */
+        prefetch: createHandler(router.prefetch)
+      };
+    }, [curLocale, nextPathname, router]);
+  }
+  return {
+    ...redirects,
+    Link,
+    usePathname,
+    useRouter,
+    getPathname
+  };
+}
+
+exports.default = createNavigation;

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

@@ -1,4 +1,3 @@
-"use client";
 'use strict';
 
 Object.defineProperty(exports, '__esModule', { value: true });
@@ -8,19 +7,6 @@ var React = require('react');
 var useLocale = require('../../react-client/useLocale.js');
 var utils = require('../../shared/utils.js');
 
-/**
- * Returns the pathname without a potential locale prefix.
- *
- * @example
- * ```tsx
- * 'use client';
- *
- * import {usePathname} from 'next-intl/client';
- *
- * // When the user is on `/en`, this will be `/`
- * const pathname = usePathname();
- * ```
- */
 function useBasePathname(localePrefix) {
   // The types aren't entirely correct here. Outside of Next.js
   // `useParams` can be called, but the return type is `null`.

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

@@ -5,13 +5,15 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.js');
 var React = require('react');
 var utils = require('../../shared/utils.js');
-var BaseLink = require('../shared/BaseLink.js');
+var LegacyBaseLink = require('../shared/LegacyBaseLink.js');
 var getLocale = require('../../server/react-server/getLocale.js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var React__default = /*#__PURE__*/_interopDefault(React);
 
+// Only used by legacy navigation APIs, can be removed when they are removed
+
 async function ServerLink(_ref) {
   let {
     locale,
@@ -20,7 +22,7 @@ async function ServerLink(_ref) {
   } = _ref;
   const finalLocale = locale || (await getLocale.default());
   const prefix = utils.getLocalePrefix(finalLocale, localePrefix);
-  return /*#__PURE__*/React__default.default.createElement(BaseLink.default, _rollupPluginBabelHelpers.extends({
+  return /*#__PURE__*/React__default.default.createElement(LegacyBaseLink.default, _rollupPluginBabelHelpers.extends({
     locale: finalLocale,
     localePrefixMode: localePrefix.mode,
     prefix: prefix

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

@@ -5,7 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.js');
 var React = require('react');
 var config = require('../../routing/config.js');
-var RequestLocale = require('../../server/react-server/RequestLocale.js');
+var RequestLocaleLegacy = require('../../server/react-server/RequestLocaleLegacy.js');
 var utils = require('../shared/utils.js');
 var ServerLink = require('./ServerLink.js');
 var redirects = require('./redirects.js');
@@ -22,7 +22,7 @@ function createLocalizedPathnamesNavigation(routing) {
       locale,
       ...rest
     } = _ref;
-    const defaultLocale = RequestLocale.getRequestLocale();
+    const defaultLocale = RequestLocaleLegacy.getRequestLocale();
     const finalLocale = locale || defaultLocale;
     return /*#__PURE__*/React__default.default.createElement(ServerLink.default, _rollupPluginBabelHelpers.extends({
       href: utils.compileLocalizedPathname({
@@ -38,7 +38,7 @@ function createLocalizedPathnamesNavigation(routing) {
     }, rest));
   }
   function redirect(href) {
-    const locale = RequestLocale.getRequestLocale();
+    const locale = RequestLocaleLegacy.getRequestLocale();
     const pathname = getPathname({
       href,
       locale
@@ -52,7 +52,7 @@ function createLocalizedPathnamesNavigation(routing) {
     }, ...args);
   }
   function permanentRedirect(href) {
-    const locale = RequestLocale.getRequestLocale();
+    const locale = RequestLocaleLegacy.getRequestLocale();
     const pathname = getPathname({
       href,
       locale

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

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var RequestLocale = require('../../server/react-server/RequestLocale.js');
+var createSharedNavigationFns = require('../shared/createSharedNavigationFns.js');
+
+function createNavigation(routing) {
+  function getLocale() {
+    return RequestLocale.getRequestLocale();
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const {
+    config,
+    ...fns
+  } = createSharedNavigationFns.default(getLocale, routing);
+  function notSupported(hookName) {
+    return () => {
+      throw new Error("`".concat(hookName, "` is not supported in Server Components. You can use this hook if you convert the calling component to a Client Component."));
+    };
+  }
+  return {
+    ...fns,
+    usePathname: notSupported('usePathname'),
+    useRouter: notSupported('useRouter')
+  };
+}
+
+exports.default = createNavigation;

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

@@ -2,12 +2,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var RequestLocale = require('../../server/react-server/RequestLocale.js');
+var RequestLocaleLegacy = require('../../server/react-server/RequestLocaleLegacy.js');
 var redirects = require('../shared/redirects.js');
 
 function createRedirectFn(redirectFn) {
   return function serverRedirect(params) {
-    const locale = RequestLocale.getRequestLocale();
+    const locale = RequestLocaleLegacy.getRequestLocale();
     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/BaseLink.js

@@ -8,7 +8,6 @@ var NextLink = require('next/link');
 var navigation = require('next/navigation');
 var React = require('react');
 var useLocale = require('../../react-client/useLocale.js');
-var utils = require('../../shared/utils.js');
 var syncLocaleCookie = require('./syncLocaleCookie.js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -18,39 +17,37 @@ var React__default = /*#__PURE__*/_interopDefault(React);
 
 function BaseLink(_ref, ref) {
   let {
+    defaultLocale,
     href,
     locale,
-    localePrefixMode,
     onClick,
     prefetch,
-    prefix,
+    unprefixed,
     ...rest
   } = _ref;
+  const curLocale = useLocale.default();
+  const isChangingLocale = locale !== curLocale;
+  const linkLocale = locale || curLocale;
+  const host = useHost();
+  const finalHref =
+  // Only after hydration (to avoid mismatches)
+  host &&
+  // If there is an `unprefixed` prop, the
+  // `defaultLocale` might differ by domain
+  unprefixed && (
+  // Unprefix the pathname if a domain matches
+  unprefixed.domains[host] === linkLocale ||
+  // … and handle unknown domains by applying the
+  // global `defaultLocale` (e.g. on localhost)
+  !Object.keys(unprefixed.domains).includes(host) && curLocale === defaultLocale && !locale) ? unprefixed.pathname : href;
+
   // 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);
   function onLinkClick(event) {
     syncLocaleCookie.default(pathname, curLocale, locale);
     if (onClick) onClick(event);
   }
-  React.useEffect(() => {
-    if (!pathname) return;
-    setLocalizedHref(utils.localizeHref(href, locale, curLocale, pathname, prefix));
-  }, [curLocale, href, locale, pathname, prefix]);
   if (isChangingLocale) {
     if (prefetch && "development" !== 'production') {
       console.error('The `prefetch` prop is currently not supported when using the `locale` prop on `Link` to switch the locale.`');
@@ -59,13 +56,19 @@ function BaseLink(_ref, ref) {
   }
   return /*#__PURE__*/React__default.default.createElement(NextLink__default.default, _rollupPluginBabelHelpers.extends({
     ref: ref,
-    href: localizedHref,
+    href: finalHref,
     hrefLang: isChangingLocale ? locale : undefined,
     onClick: onLinkClick,
     prefetch: prefetch
   }, rest));
 }
-const BaseLinkWithRef = /*#__PURE__*/React.forwardRef(BaseLink);
-BaseLinkWithRef.displayName = 'ClientLink';
+function useHost() {
+  const [host, setHost] = React.useState();
+  React.useEffect(() => {
+    setHost(window.location.host);
+  }, []);
+  return host;
+}
+var BaseLink$1 = /*#__PURE__*/React.forwardRef(BaseLink);
 
-exports.default = BaseLinkWithRef;
+exports.default = BaseLink$1;

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

@@ -0,0 +1,55 @@
+"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,
+    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
+  }, rest));
+}
+const LegacyBaseLinkWithRef = /*#__PURE__*/React.forwardRef(LegacyBaseLink);
+LegacyBaseLinkWithRef.displayName = 'ClientLink';
+
+exports.default = LegacyBaseLinkWithRef;

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

@@ -0,0 +1,147 @@
+'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
+      // 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/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;