next-intl 3.14.1 → 3.15.0

package/dist/development/config.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 function getConfig() {
-  throw new Error("Couldn't find next-intl config file. Please follow the instructions at https://next-intl-docs.vercel.app/docs/getting-started/app-router-server-components");
+  throw new Error("Couldn't find next-intl config file. Please follow the instructions at https://next-intl-docs.vercel.app/docs/getting-started/app-router");
 }
 
 exports.default = getConfig;

package/dist/development/middleware/config.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var config = require('../routing/config.js');
+
+function receiveConfig(input) {
+  var _input$alternateLinks, _input$localeDetectio;
+  return {
+    ...input,
+    alternateLinks: (_input$alternateLinks = input === null || input === void 0 ? void 0 : input.alternateLinks) !== null && _input$alternateLinks !== void 0 ? _input$alternateLinks : true,
+    localeDetection: (_input$localeDetectio = input === null || input === void 0 ? void 0 : input.localeDetection) !== null && _input$localeDetectio !== void 0 ? _input$localeDetectio : true,
+    localePrefix: config.receiveLocalePrefixConfig(input === null || input === void 0 ? void 0 : input.localePrefix)
+  };
+}
+
+exports.receiveConfig = receiveConfig;

package/dist/development/middleware/getAlternateLinksHeaderValue.js

@@ -22,7 +22,7 @@ function getAlternateLinksHeaderValue(_ref) {
     normalizedUrl.host = host;
   }
   normalizedUrl.protocol = (_request$headers$get = request.headers.get('x-forwarded-proto')) !== null && _request$headers$get !== void 0 ? _request$headers$get : normalizedUrl.protocol;
-  normalizedUrl.pathname = utils.getNormalizedPathname(normalizedUrl.pathname, config.locales);
+  normalizedUrl.pathname = utils.getNormalizedPathname(normalizedUrl.pathname, config.locales, config.localePrefix);
   function getAlternateEntry(url, locale) {
     if (request.nextUrl.basePath) {
       url = new URL(url);
@@ -37,12 +37,13 @@ function getAlternateLinksHeaderValue(_ref) {
       return pathname;
     }
   }
-  const links = config.locales.flatMap(locale => {
+  const links = utils.getLocalePrefixes(config.locales, config.localePrefix).flatMap(_ref2 => {
+    let [locale, prefix] = _ref2;
     function prefixPathname(pathname) {
       if (pathname === '/') {
-        return "/".concat(locale);
+        return prefix;
       } else {
-        return "/".concat(locale).concat(pathname);
+        return prefix + pathname;
       }
     }
     let url;
@@ -56,7 +57,7 @@ function getAlternateLinksHeaderValue(_ref) {
         // Important: Use `normalizedUrl` here, as `url` potentially uses
         // a `basePath` that automatically gets applied to the pathname
         url.pathname = getLocalizedPathname(normalizedUrl.pathname, locale);
-        if (locale !== domainConfig.defaultLocale || config.localePrefix === 'always') {
+        if (locale !== domainConfig.defaultLocale || config.localePrefix.mode === 'always') {
           url.pathname = prefixPathname(url.pathname);
         }
         return getAlternateEntry(url, locale);
@@ -68,7 +69,7 @@ function getAlternateLinksHeaderValue(_ref) {
       } else {
         pathname = normalizedUrl.pathname;
       }
-      if (locale !== config.defaultLocale || config.localePrefix === 'always') {
+      if (locale !== config.defaultLocale || config.localePrefix.mode === 'always') {
         pathname = prefixPathname(pathname);
       }
       url = new URL(pathname, normalizedUrl);
@@ -79,7 +80,7 @@ function getAlternateLinksHeaderValue(_ref) {
   // Add x-default entry
   const shouldAddXDefault =
   // For domain-based routing there is no reasonable x-default
-  !config.domains && (config.localePrefix !== 'always' || normalizedUrl.pathname === '/');
+  !config.domains && (config.localePrefix.mode !== 'always' || normalizedUrl.pathname === '/');
   if (shouldAddXDefault) {
     const url = new URL(getLocalizedPathname(normalizedUrl.pathname, config.defaultLocale), normalizedUrl);
     links.push(getAlternateEntry(url, 'x-default'));

package/dist/development/middleware/middleware.js

@@ -5,61 +5,46 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var server = require('next/server');
 var constants = require('../shared/constants.js');
 var utils$1 = require('../shared/utils.js');
+var config = require('./config.js');
 var getAlternateLinksHeaderValue = require('./getAlternateLinksHeaderValue.js');
 var resolveLocale = require('./resolveLocale.js');
+var syncCookie = require('./syncCookie.js');
 var utils = require('./utils.js');
 
-const ROOT_URL = '/';
-function receiveConfig(config) {
-  var _config$alternateLink, _config$localePrefix, _config$localeDetecti;
-  const result = {
-    ...config,
-    alternateLinks: (_config$alternateLink = config.alternateLinks) !== null && _config$alternateLink !== void 0 ? _config$alternateLink : true,
-    localePrefix: (_config$localePrefix = config.localePrefix) !== null && _config$localePrefix !== void 0 ? _config$localePrefix : 'always',
-    localeDetection: (_config$localeDetecti = config.localeDetection) !== null && _config$localeDetecti !== void 0 ? _config$localeDetecti : true
-  };
-  return result;
-}
-function createMiddleware(config) {
-  const configWithDefaults = receiveConfig(config);
+function createMiddleware(input) {
+  const config$1 = config.receiveConfig(input);
   return function middleware(request) {
-    var _request$cookies$get, _configWithDefaults$d;
+    var _config$domains;
     // Resolve potential foreign symbols (e.g. /ja/%E7%B4%84 → /ja/約))
-    const nextPathname = decodeURI(request.nextUrl.pathname);
+    const externalPathname = decodeURI(request.nextUrl.pathname);
     const {
       domain,
       locale
-    } = resolveLocale.default(configWithDefaults, request.headers, request.cookies, nextPathname);
-    const hasOutdatedCookie = configWithDefaults.localeDetection && ((_request$cookies$get = request.cookies.get(constants.COOKIE_LOCALE_NAME)) === null || _request$cookies$get === void 0 ? void 0 : _request$cookies$get.value) !== locale;
-    const hasMatchedDefaultLocale = domain ? domain.defaultLocale === locale : locale === configWithDefaults.defaultLocale;
-    const domainConfigs = ((_configWithDefaults$d = configWithDefaults.domains) === null || _configWithDefaults$d === void 0 ? void 0 : _configWithDefaults$d.filter(curDomain => utils.isLocaleSupportedOnDomain(locale, curDomain))) || [];
-    const hasUnknownHost = configWithDefaults.domains != null && !domain;
-    function getResponseInit() {
-      const headers = new Headers(request.headers);
-      headers.set(constants.HEADER_LOCALE_NAME, locale);
-      return {
-        request: {
-          headers
-        }
-      };
-    }
+    } = resolveLocale.default(config$1, request.headers, request.cookies, externalPathname);
+    const hasMatchedDefaultLocale = domain ? domain.defaultLocale === locale : locale === config$1.defaultLocale;
+    const domainConfigs = ((_config$domains = config$1.domains) === null || _config$domains === void 0 ? void 0 : _config$domains.filter(curDomain => utils.isLocaleSupportedOnDomain(locale, curDomain))) || [];
+    const hasUnknownHost = config$1.domains != null && !domain;
     function rewrite(url) {
       const urlObj = new URL(url, request.url);
       if (request.nextUrl.basePath) {
         urlObj.pathname = utils.applyBasePath(urlObj.pathname, request.nextUrl.basePath);
       }
-      return server.NextResponse.rewrite(urlObj, getResponseInit());
+      const headers = new Headers(request.headers);
+      headers.set(constants.HEADER_LOCALE_NAME, locale);
+      return server.NextResponse.rewrite(urlObj, {
+        request: {
+          headers
+        }
+      });
     }
     function redirect(url, redirectDomain) {
-      const urlObj = new URL(url, request.url);
-      if (domainConfigs.length > 0) {
-        if (!redirectDomain) {
-          const bestMatchingDomain = utils.getBestMatchingDomain(domain, locale, domainConfigs);
-          if (bestMatchingDomain) {
-            redirectDomain = bestMatchingDomain.domain;
-            if (bestMatchingDomain.defaultLocale === locale && configWithDefaults.localePrefix === 'as-needed' && urlObj.pathname.startsWith("/".concat(locale))) {
-              urlObj.pathname = utils.getNormalizedPathname(urlObj.pathname, configWithDefaults.locales);
-            }
+      const urlObj = new URL(utils.normalizeTrailingSlash(url), request.url);
+      if (domainConfigs.length > 0 && !redirectDomain) {
+        const bestMatchingDomain = utils.getBestMatchingDomain(domain, locale, domainConfigs);
+        if (bestMatchingDomain) {
+          redirectDomain = bestMatchingDomain.domain;
+          if (bestMatchingDomain.defaultLocale === locale && config$1.localePrefix.mode === 'as-needed') {
+            urlObj.pathname = utils.getNormalizedPathname(urlObj.pathname, config$1.locales, config$1.localePrefix);
           }
         }
       }
@@ -76,88 +61,89 @@ function createMiddleware(config) {
       }
       return server.NextResponse.redirect(urlObj.toString());
     }
-    const normalizedPathname = utils.getNormalizedPathname(nextPathname, configWithDefaults.locales);
-    const pathLocale = utils.getPathnameLocale(nextPathname, configWithDefaults.locales);
-    const hasLocalePrefix = pathLocale != null;
+    const unprefixedExternalPathname = utils.getNormalizedPathname(externalPathname, config$1.locales, config$1.localePrefix);
+    const pathnameMatch = utils.getPathnameMatch(externalPathname, config$1.locales, config$1.localePrefix);
+    const hasLocalePrefix = pathnameMatch != null;
+    const isUnprefixedRouting = config$1.localePrefix.mode === 'never' || hasMatchedDefaultLocale && config$1.localePrefix.mode === 'as-needed';
     let response;
     let internalTemplateName;
-    let pathname = nextPathname;
-    if (configWithDefaults.pathnames) {
+    let unprefixedInternalPathname = unprefixedExternalPathname;
+    if (config$1.pathnames) {
       let resolvedTemplateLocale;
-      [resolvedTemplateLocale, internalTemplateName] = utils.getInternalTemplate(configWithDefaults.pathnames, normalizedPathname, locale);
+      [resolvedTemplateLocale, internalTemplateName] = utils.getInternalTemplate(config$1.pathnames, unprefixedExternalPathname, locale);
       if (internalTemplateName) {
-        const pathnameConfig = configWithDefaults.pathnames[internalTemplateName];
-        const localeTemplate = typeof pathnameConfig === 'string' ? pathnameConfig : pathnameConfig[locale];
-        if (utils$1.matchesPathname(localeTemplate, normalizedPathname)) {
-          pathname = utils.formatTemplatePathname(normalizedPathname, localeTemplate, internalTemplateName, pathLocale);
+        const pathnameConfig = config$1.pathnames[internalTemplateName];
+        const localeTemplate = typeof pathnameConfig === 'string' ? pathnameConfig :
+        // @ts-expect-error This is ok
+        pathnameConfig[locale];
+        if (utils$1.matchesPathname(localeTemplate, unprefixedExternalPathname)) {
+          unprefixedInternalPathname = utils.formatTemplatePathname(unprefixedExternalPathname, localeTemplate, internalTemplateName);
         } else {
           let sourceTemplate;
           if (resolvedTemplateLocale) {
             // A localized pathname from another locale has matched
-            sourceTemplate = typeof pathnameConfig === 'string' ? pathnameConfig : pathnameConfig[resolvedTemplateLocale];
+            sourceTemplate = typeof pathnameConfig === 'string' ? pathnameConfig :
+            // @ts-expect-error This is ok
+            pathnameConfig[resolvedTemplateLocale];
           } else {
             // An internal pathname has matched that
             // doesn't have a localized pathname
             sourceTemplate = internalTemplateName;
           }
-          const localePrefix = (hasLocalePrefix || !hasMatchedDefaultLocale) && configWithDefaults.localePrefix !== 'never' ? locale : undefined;
-          response = redirect(utils.getPathWithSearch(utils.formatTemplatePathname(normalizedPathname, sourceTemplate, localeTemplate, localePrefix), request.nextUrl.search));
+          const localePrefix = isUnprefixedRouting ? undefined : utils$1.getLocalePrefix(locale, config$1.localePrefix);
+          const template = utils.formatTemplatePathname(unprefixedExternalPathname, sourceTemplate, localeTemplate);
+          response = redirect(utils.formatPathname(template, localePrefix, request.nextUrl.search));
         }
       }
     }
     if (!response) {
-      if (pathname === ROOT_URL) {
-        const pathWithSearch = utils.getPathWithSearch("/".concat(locale), request.nextUrl.search);
-        if (configWithDefaults.localePrefix === 'never' || hasMatchedDefaultLocale && configWithDefaults.localePrefix === 'as-needed') {
-          response = rewrite(pathWithSearch);
+      if (unprefixedInternalPathname === '/' && !hasLocalePrefix) {
+        if (isUnprefixedRouting) {
+          response = rewrite(utils.formatPathname(unprefixedInternalPathname, utils.getLocaleAsPrefix(locale), request.nextUrl.search));
         } else {
-          response = redirect(pathWithSearch);
+          response = redirect(utils.formatPathname(unprefixedExternalPathname, utils$1.getLocalePrefix(locale, config$1.localePrefix), request.nextUrl.search));
         }
       } else {
-        const internalPathWithSearch = utils.getPathWithSearch(pathname, request.nextUrl.search);
+        const internalHref = utils.formatPathname(unprefixedInternalPathname, utils.getLocaleAsPrefix(locale), request.nextUrl.search);
         if (hasLocalePrefix) {
-          const normalizedPathnameWithSearch = utils.getPathWithSearch(normalizedPathname, request.nextUrl.search);
-          if (configWithDefaults.localePrefix === 'never') {
-            response = redirect(normalizedPathnameWithSearch);
-          } else if (pathLocale === locale) {
-            if (hasMatchedDefaultLocale && configWithDefaults.localePrefix === 'as-needed') {
-              response = redirect(normalizedPathnameWithSearch);
+          const externalHref = utils.formatPathname(unprefixedExternalPathname, pathnameMatch.prefix, request.nextUrl.search);
+          if (config$1.localePrefix.mode === 'never') {
+            response = redirect(utils.formatPathname(unprefixedExternalPathname, undefined, request.nextUrl.search));
+          } else if (pathnameMatch.exact) {
+            if (hasMatchedDefaultLocale && isUnprefixedRouting) {
+              response = redirect(utils.formatPathname(unprefixedExternalPathname, undefined, request.nextUrl.search));
             } else {
-              if (configWithDefaults.domains) {
-                const pathDomain = utils.getBestMatchingDomain(domain, pathLocale, domainConfigs);
+              if (config$1.domains) {
+                const pathDomain = utils.getBestMatchingDomain(domain, pathnameMatch.locale, domainConfigs);
                 if ((domain === null || domain === void 0 ? void 0 : domain.domain) !== (pathDomain === null || pathDomain === void 0 ? void 0 : pathDomain.domain) && !hasUnknownHost) {
-                  response = redirect(normalizedPathnameWithSearch, pathDomain === null || pathDomain === void 0 ? void 0 : pathDomain.domain);
+                  response = redirect(externalHref, pathDomain === null || pathDomain === void 0 ? void 0 : pathDomain.domain);
                 } else {
-                  response = rewrite(internalPathWithSearch);
+                  response = rewrite(internalHref);
                 }
               } else {
-                response = rewrite(internalPathWithSearch);
+                response = rewrite(internalHref);
               }
             }
           } else {
-            response = redirect("/".concat(locale).concat(normalizedPathnameWithSearch));
+            response = redirect(externalHref);
           }
         } else {
-          if (configWithDefaults.localePrefix === 'never' || hasMatchedDefaultLocale && (configWithDefaults.localePrefix === 'as-needed' || configWithDefaults.domains)) {
-            response = rewrite("/".concat(locale).concat(internalPathWithSearch));
+          if (isUnprefixedRouting) {
+            response = rewrite(internalHref);
           } else {
-            response = redirect("/".concat(locale).concat(internalPathWithSearch));
+            response = redirect(utils.formatPathname(unprefixedExternalPathname, utils$1.getLocalePrefix(locale, config$1.localePrefix), request.nextUrl.search));
           }
         }
       }
     }
-    if (hasOutdatedCookie) {
-      response.cookies.set(constants.COOKIE_LOCALE_NAME, locale, {
-        path: request.nextUrl.basePath || undefined,
-        sameSite: constants.COOKIE_SAME_SITE,
-        maxAge: constants.COOKIE_MAX_AGE
-      });
+    if (config$1.localeDetection) {
+      syncCookie.default(request, response, locale);
     }
-    if (configWithDefaults.localePrefix !== 'never' && configWithDefaults.alternateLinks && configWithDefaults.locales.length > 1) {
-      var _configWithDefaults$p;
+    if (config$1.localePrefix.mode !== 'never' && config$1.alternateLinks && config$1.locales.length > 1) {
+      var _config$pathnames;
       response.headers.set('Link', getAlternateLinksHeaderValue.default({
-        config: configWithDefaults,
-        localizedPathnames: internalTemplateName != null ? (_configWithDefaults$p = configWithDefaults.pathnames) === null || _configWithDefaults$p === void 0 ? void 0 : _configWithDefaults$p[internalTemplateName] : undefined,
+        config: config$1,
+        localizedPathnames: internalTemplateName != null ? (_config$pathnames = config$1.pathnames) === null || _config$pathnames === void 0 ? void 0 : _config$pathnames[internalTemplateName] : undefined,
         request,
         resolvedLocale: locale
       }));

package/dist/development/middleware/resolveLocale.js

@@ -36,10 +36,6 @@ function getAcceptLanguageLocale(requestHeaders, locales, defaultLocale) {
   }
   return locale;
 }
-function getLocaleFromPrefix(pathname, locales) {
-  const pathLocaleCandidate = utils.getFirstPathnameSegment(pathname);
-  return utils.findCaseInsensitiveLocale(pathLocaleCandidate, locales);
-}
 function getLocaleFromCookie(requestCookies, locales) {
   if (requestCookies.has(constants.COOKIE_LOCALE_NAME)) {
     var _requestCookies$get;
@@ -53,13 +49,15 @@ function resolveLocaleFromPrefix(_ref, requestHeaders, requestCookies, pathname)
   let {
     defaultLocale,
     localeDetection,
+    localePrefix,
     locales
   } = _ref;
   let locale;
 
   // Prio 1: Use route prefix
   if (pathname) {
-    locale = getLocaleFromPrefix(pathname, locales);
+    var _getPathnameMatch;
+    locale = (_getPathnameMatch = utils.getPathnameMatch(pathname, locales, localePrefix)) === null || _getPathnameMatch === void 0 ? void 0 : _getPathnameMatch.locale;
   }
 
   // Prio 2: Use existing cookie
@@ -90,7 +88,8 @@ function resolveLocaleFromDomain(config, requestHeaders, requestCookies, pathnam
 
   // Prio 1: Use route prefix
   if (pathname) {
-    const prefixLocale = getLocaleFromPrefix(pathname, config.locales);
+    var _getPathnameMatch2;
+    const prefixLocale = (_getPathnameMatch2 = utils.getPathnameMatch(pathname, config.locales, config.localePrefix)) === null || _getPathnameMatch2 === void 0 ? void 0 : _getPathnameMatch2.locale;
     if (prefixLocale) {
       if (utils.isLocaleSupportedOnDomain(prefixLocale, domain)) {
         locale = prefixLocale;

package/dist/development/middleware/syncCookie.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../shared/constants.js');
+
+function syncCookie(request, response, locale) {
+  var _request$cookies$get;
+  const hasOutdatedCookie = ((_request$cookies$get = request.cookies.get(constants.COOKIE_LOCALE_NAME)) === null || _request$cookies$get === void 0 ? void 0 : _request$cookies$get.value) !== locale;
+  if (hasOutdatedCookie) {
+    response.cookies.set(constants.COOKIE_LOCALE_NAME, locale, {
+      path: request.nextUrl.basePath || undefined,
+      sameSite: constants.COOKIE_SAME_SITE,
+      maxAge: constants.COOKIE_MAX_AGE
+    });
+  }
+}
+
+exports.default = syncCookie;

package/dist/development/middleware/utils.js

@@ -4,9 +4,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var utils = require('../shared/utils.js');
 
-function getFirstPathnameSegment(pathname) {
-  return pathname.split('/')[1];
-}
 function isOptionalCatchAllSegment(pathname) {
   return pathname.includes('[[...');
 }
@@ -94,40 +91,64 @@ function getInternalTemplate(pathnames, pathname, locale) {
   // No match
   return [undefined, undefined];
 }
-function formatTemplatePathname(sourcePathname, sourceTemplate, targetTemplate, localePrefix) {
+function formatTemplatePathname(sourcePathname, sourceTemplate, targetTemplate, prefix) {
   const params = getRouteParams(sourceTemplate, sourcePathname);
   let targetPathname = '';
-  if (localePrefix) {
-    targetPathname = "/".concat(localePrefix);
+  if (prefix) {
+    targetPathname = "/".concat(prefix);
   }
-  targetPathname += formatPathname(targetTemplate, params);
+  targetPathname += formatPathnameTemplate(targetTemplate, params);
   targetPathname = normalizeTrailingSlash(targetPathname);
   return targetPathname;
 }
 
 /**
- * Removes potential locales from the pathname.
+ * Removes potential prefixes from the pathname.
  */
-function getNormalizedPathname(pathname, locales) {
+function getNormalizedPathname(pathname, locales, localePrefix) {
   // Add trailing slash for consistent handling
   // both for the root as well as nested paths
   if (!pathname.endsWith('/')) {
     pathname += '/';
   }
-  const match = pathname.match(new RegExp("^/(".concat(locales.join('|'), ")/(.*)"), 'i'));
+  const localePrefixes = getLocalePrefixes(locales, localePrefix);
+  const regex = new RegExp("^(".concat(localePrefixes.map(_ref2 => {
+    let [, prefix] = _ref2;
+    return prefix.replaceAll('/', '\\/');
+  }).join('|'), ")/(.*)"), 'i');
+  const match = pathname.match(regex);
   let result = match ? '/' + match[2] : pathname;
   if (result !== '/') {
     result = normalizeTrailingSlash(result);
   }
   return result;
 }
-function findCaseInsensitiveLocale(candidate, locales) {
-  return locales.find(locale => locale.toLowerCase() === candidate.toLowerCase());
+function getLocalePrefixes(locales, localePrefix) {
+  return locales.map(locale => [locale, utils.getLocalePrefix(locale, localePrefix)]);
 }
-function getPathnameLocale(pathname, locales) {
-  const pathLocaleCandidate = getFirstPathnameSegment(pathname);
-  const pathLocale = findCaseInsensitiveLocale(pathLocaleCandidate, locales) ? pathLocaleCandidate : undefined;
-  return pathLocale;
+function getPathnameMatch(pathname, locales, localePrefix) {
+  const localePrefixes = getLocalePrefixes(locales, localePrefix);
+  for (const [locale, prefix] of localePrefixes) {
+    let exact, matches;
+    if (pathname === prefix || pathname.startsWith(prefix + '/')) {
+      exact = matches = true;
+    } else {
+      const normalizedPathname = pathname.toLowerCase();
+      const normalizedPrefix = prefix.toLowerCase();
+      if (normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(normalizedPrefix + '/')) {
+        exact = false;
+        matches = true;
+      }
+    }
+    if (matches) {
+      return {
+        locale,
+        prefix,
+        matchedPrefix: pathname.slice(0, prefix.length),
+        exact
+      };
+    }
+  }
 }
 function getRouteParams(template, pathname) {
   const regex = utils.templateToRegex(template);
@@ -141,29 +162,32 @@ function getRouteParams(template, pathname) {
   }
   return params;
 }
-function formatPathname(template, params) {
+function formatPathnameTemplate(template, params) {
   if (!params) return template;
 
   // Simplify syntax for optional catchall ('[[...slug]]') so
   // we can replace the value with simple interpolation
   template = template.replace(/\[\[/g, '[').replace(/\]\]/g, ']');
   let result = template;
-  Object.entries(params).forEach(_ref2 => {
-    let [key, value] = _ref2;
+  Object.entries(params).forEach(_ref3 => {
+    let [key, value] = _ref3;
     result = result.replace("[".concat(key, "]"), value);
   });
   return result;
 }
-function getPathWithSearch(pathname, search) {
-  let pathWithSearch = pathname;
+function formatPathname(pathname, prefix, search) {
+  let result = pathname;
+  if (prefix) {
+    result = utils.prefixPathname(prefix, result);
+  }
   if (search) {
-    pathWithSearch += search;
+    result += search;
   }
-  return pathWithSearch;
+  return result;
 }
 function getHost(requestHeaders) {
-  var _ref3, _requestHeaders$get;
-  return (_ref3 = (_requestHeaders$get = requestHeaders.get('x-forwarded-host')) !== null && _requestHeaders$get !== void 0 ? _requestHeaders$get : requestHeaders.get('host')) !== null && _ref3 !== void 0 ? _ref3 : undefined;
+  var _ref4, _requestHeaders$get;
+  return (_ref4 = (_requestHeaders$get = requestHeaders.get('x-forwarded-host')) !== null && _requestHeaders$get !== void 0 ? _requestHeaders$get : requestHeaders.get('host')) !== null && _ref4 !== void 0 ? _ref4 : undefined;
 }
 function isLocaleSupportedOnDomain(locale, domain) {
   return domain.defaultLocale === locale || !domain.locales || domain.locales.includes(locale);
@@ -201,24 +225,28 @@ function applyBasePath(pathname, basePath) {
   return normalizeTrailingSlash(basePath + pathname);
 }
 function normalizeTrailingSlash(pathname) {
-  if (pathname.endsWith('/')) {
+  if (pathname !== '/' && pathname.endsWith('/')) {
     pathname = pathname.slice(0, -1);
   }
   return pathname;
 }
+function getLocaleAsPrefix(locale) {
+  return "/".concat(locale);
+}
 
 exports.applyBasePath = applyBasePath;
 exports.comparePathnamePairs = comparePathnamePairs;
-exports.findCaseInsensitiveLocale = findCaseInsensitiveLocale;
 exports.formatPathname = formatPathname;
+exports.formatPathnameTemplate = formatPathnameTemplate;
 exports.formatTemplatePathname = formatTemplatePathname;
 exports.getBestMatchingDomain = getBestMatchingDomain;
-exports.getFirstPathnameSegment = getFirstPathnameSegment;
 exports.getHost = getHost;
 exports.getInternalTemplate = getInternalTemplate;
+exports.getLocaleAsPrefix = getLocaleAsPrefix;
+exports.getLocalePrefixes = getLocalePrefixes;
 exports.getNormalizedPathname = getNormalizedPathname;
-exports.getPathWithSearch = getPathWithSearch;
-exports.getPathnameLocale = getPathnameLocale;
+exports.getPathnameMatch = getPathnameMatch;
 exports.getRouteParams = getRouteParams;
 exports.getSortedPathnames = getSortedPathnames;
 exports.isLocaleSupportedOnDomain = isLocaleSupportedOnDomain;
+exports.normalizeTrailingSlash = normalizeTrailingSlash;

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.js');
 var React = require('react');
 var useLocale = require('../../react-client/useLocale.js');
+var utils = require('../../shared/utils.js');
 var BaseLink = require('../shared/BaseLink.js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -14,13 +15,17 @@ var React__default = /*#__PURE__*/_interopDefault(React);
 function ClientLink(_ref, ref) {
   let {
     locale,
+    localePrefix,
     ...rest
   } = _ref;
   const defaultLocale = useLocale.default();
-  const linkLocale = locale || defaultLocale;
+  const finalLocale = locale || defaultLocale;
+  const prefix = utils.getLocalePrefix(finalLocale, localePrefix);
   return /*#__PURE__*/React__default.default.createElement(BaseLink.default, _rollupPluginBabelHelpers.extends({
     ref: ref,
-    locale: linkLocale
+    locale: finalLocale,
+    localePrefixMode: localePrefix.mode,
+    prefix: prefix
   }, rest));
 }
 

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

@@ -5,10 +5,10 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.js');
 var React = require('react');
 var useLocale = require('../../react-client/useLocale.js');
+var config = require('../shared/config.js');
 var utils = require('../shared/utils.js');
 var ClientLink = require('./ClientLink.js');
-var clientPermanentRedirect = require('./clientPermanentRedirect.js');
-var clientRedirect = require('./clientRedirect.js');
+var redirects = require('./redirects.js');
 var useBasePathname = require('./useBasePathname.js');
 var useBaseRouter = require('./useBaseRouter.js');
 
@@ -16,10 +16,11 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var React__default = /*#__PURE__*/_interopDefault(React);
 
-function createLocalizedPathnamesNavigation(opts) {
+function createLocalizedPathnamesNavigation(input) {
+  const config$1 = config.receiveLocalizedNavigationRoutingConfig(input);
   function useTypedLocale() {
     const locale = useLocale.default();
-    const isValid = opts.locales.includes(locale);
+    const isValid = config$1.locales.includes(locale);
     if (!isValid) {
       throw new Error("Unknown locale encountered: \"".concat(locale, "\". Make sure to validate the locale in `i18n.ts`.") );
     }
@@ -41,10 +42,10 @@ function createLocalizedPathnamesNavigation(opts) {
         pathname: href,
         // @ts-expect-error -- This is ok
         params: typeof href === 'object' ? href.params : undefined,
-        pathnames: opts.pathnames
+        pathnames: config$1.pathnames
       }),
       locale: locale,
-      localePrefix: opts.localePrefix
+      localePrefix: config$1.localePrefix
     }, rest));
   }
   const LinkWithRef = /*#__PURE__*/React.forwardRef(Link);
@@ -59,9 +60,9 @@ function createLocalizedPathnamesNavigation(opts) {
     for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
       args[_key - 1] = arguments[_key];
     }
-    return clientRedirect.default({
-      ...opts,
-      pathname: resolvedHref
+    return redirects.clientRedirect({
+      pathname: resolvedHref,
+      localePrefix: config$1.localePrefix
     }, ...args);
   }
   function permanentRedirect(href) {
@@ -74,13 +75,13 @@ function createLocalizedPathnamesNavigation(opts) {
     for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
       args[_key2 - 1] = arguments[_key2];
     }
-    return clientPermanentRedirect.default({
-      ...opts,
-      pathname: resolvedHref
+    return redirects.clientPermanentRedirect({
+      pathname: resolvedHref,
+      localePrefix: config$1.localePrefix
     }, ...args);
   }
   function useRouter() {
-    const baseRouter = useBaseRouter.default();
+    const baseRouter = useBaseRouter.default(config$1.localePrefix);
     const defaultLocale = useTypedLocale();
     return {
       ...baseRouter,
@@ -120,13 +121,14 @@ function createLocalizedPathnamesNavigation(opts) {
     };
   }
   function usePathname() {
-    const pathname = useBasePathname.default();
+    const pathname = useBasePathname.default(config$1.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 pathname ? utils.getRoute({
       pathname,
       locale,
-      pathnames: opts.pathnames
+      pathnames: config$1.pathnames
     }) : pathname;
   }
   function getPathname(_ref2) {
@@ -137,7 +139,7 @@ function createLocalizedPathnamesNavigation(opts) {
     return utils.compileLocalizedPathname({
       ...utils.normalizeNameOrNameWithParams(href),
       locale,
-      pathnames: opts.pathnames
+      pathnames: config$1.pathnames
     });
   }
   return {