@depup/next-intl 4.8.3-depup.0

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

@@ -0,0 +1,80 @@
+import { useRouter, usePathname } from 'next/navigation';
+import { useMemo } from 'react';
+import { useLocale } from 'use-intl';
+import createSharedNavigationFns from '../shared/createSharedNavigationFns.js';
+import syncLocaleCookie from '../shared/syncLocaleCookie.js';
+import { getRoute } from '../shared/utils.js';
+import useBasePathname from './useBasePathname.js';
+
+function createNavigation(routing) {
+  const {
+    Link,
+    config,
+    getPathname,
+    ...redirects
+  } = createSharedNavigationFns(useLocale, routing);
+
+  /** @see https://next-intl.dev/docs/routing/navigation#usepathname */
+  function usePathname$1() {
+    const pathname = useBasePathname(config);
+    const locale = useLocale();
+
+    // @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 useMemo(() => pathname &&
+    // @ts-expect-error -- This is fine
+    config.pathnames ? getRoute(locale, pathname,
+    // @ts-expect-error -- This is fine
+    config.pathnames) : pathname, [locale, pathname]);
+  }
+  function useRouter$1() {
+    const router = useRouter();
+    const curLocale = useLocale();
+    const nextPathname = usePathname();
+    return useMemo(() => {
+      function createHandler(fn) {
+        return function handler(href, options) {
+          const {
+            locale: nextLocale,
+            ...rest
+          } = options || {};
+          const pathname = getPathname({
+            href,
+            locale: nextLocale || curLocale,
+            // Always include a prefix when changing locales. Theoretically,
+            // this is only necessary for the case described in #2020. However,
+            // the full detection is rather expensive, and this behavior is
+            // consistent with the `Link` component. The downside is an
+            // additional redirect for users in other situations. Locale
+            // changes should be rare though, so this might be fine.
+            forcePrefix: nextLocale != null || undefined
+          });
+          const args = [pathname];
+          if (Object.keys(rest).length > 0) {
+            // @ts-expect-error -- This is fine
+            args.push(rest);
+          }
+          syncLocaleCookie(config.localeCookie, nextPathname, curLocale, nextLocale);
+          fn(...args);
+        };
+      }
+      return {
+        ...router,
+        /** @see https://next-intl.dev/docs/routing/navigation#userouter */
+        push: createHandler(router.push),
+        /** @see https://next-intl.dev/docs/routing/navigation#userouter */
+        replace: createHandler(router.replace),
+        /** @see https://next-intl.dev/docs/routing/navigation#userouter */
+        prefetch: createHandler(router.prefetch)
+      };
+    }, [curLocale, nextPathname, router]);
+  }
+  return {
+    ...redirects,
+    Link,
+    usePathname: usePathname$1,
+    useRouter: useRouter$1,
+    getPathname
+  };
+}
+
+export { createNavigation as default };

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

@@ -0,0 +1,36 @@
+import { usePathname } from 'next/navigation';
+import { useMemo } from 'react';
+import { useLocale } from 'use-intl';
+import { hasPathnamePrefixed, unprefixPathname, getLocalePrefix, getLocaleAsPrefix } from '../../shared/utils.js';
+
+function useBasePathname(config) {
+  // The types aren't entirely correct here. Outside of Next.js
+  // `useParams` can be called, but the return type is `null`.
+
+  // Notes on `useNextPathname`:
+  // - Types aren't entirely correct. Outside of Next.js the
+  //   hook will return `null` (e.g. unit tests)
+  // - A base path is stripped from the result
+  // - Rewrites *are* taken into account (i.e. the pathname
+  //   that the user sees in the browser is returned)
+  const pathname = usePathname();
+  const locale = useLocale();
+  return useMemo(() => {
+    if (!pathname) return pathname;
+    let unlocalizedPathname = pathname;
+    const prefix = getLocalePrefix(locale, config.localePrefix);
+    const isPathnamePrefixed = hasPathnamePrefixed(prefix, pathname);
+    if (isPathnamePrefixed) {
+      unlocalizedPathname = unprefixPathname(pathname, prefix);
+    } else if (config.localePrefix.mode !== 'never' && config.localePrefix.prefixes) {
+      // Workaround for https://github.com/vercel/next.js/issues/73085
+      const localeAsPrefix = getLocaleAsPrefix(locale);
+      if (hasPathnamePrefixed(localeAsPrefix, pathname)) {
+        unlocalizedPathname = unprefixPathname(pathname, localeAsPrefix);
+      }
+    }
+    return unlocalizedPathname;
+  }, [config.localePrefix, locale, pathname]);
+}
+
+export { useBasePathname as default };

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

@@ -0,0 +1,22 @@
+import createSharedNavigationFns from '../shared/createSharedNavigationFns.js';
+import getServerLocale from './getServerLocale.js';
+
+function createNavigation(routing) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const {
+    config,
+    ...fns
+  } = createSharedNavigationFns(getServerLocale, routing);
+  function notSupported(hookName) {
+    return () => {
+      throw new Error(`\`${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')
+  };
+}
+
+export { createNavigation as default };

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

@@ -0,0 +1,12 @@
+import getConfig from '../../server/react-server/getConfig.js';
+
+/**
+ * This is only moved to a separate module for easier mocking in
+ * `../createNavigatoin.test.tsx` in order to avoid suspending.
+ */
+async function getServerLocale() {
+  const config = await getConfig();
+  return config.locale;
+}
+
+export { getServerLocale as default };

package/dist/esm/development/navigation/shared/BaseLink.js

@@ -0,0 +1,51 @@
+"use client";
+import NextLink from 'next/link';
+import { usePathname } from 'next/navigation';
+import { forwardRef } from 'react';
+import { useLocale } from 'use-intl';
+import syncLocaleCookie from './syncLocaleCookie.js';
+import { jsx } from 'react/jsx-runtime';
+
+function BaseLink({
+  href,
+  locale,
+  localeCookie,
+  onClick,
+  prefetch,
+  ...rest
+}, ref) {
+  const curLocale = useLocale();
+  const isChangingLocale = locale != null && locale !== curLocale;
+
+  // The types aren't entirely correct here. Outside of Next.js
+  // `useParams` can be called, but the return type is `null`.
+  const pathname = usePathname();
+  function onLinkClick(event) {
+    // Even though we force a prefix when changing locales,
+    // this could be a cache hit of the client-side router,
+    // therefore we sync the cookie to ensure it's up to date.
+    syncLocaleCookie(localeCookie, pathname, curLocale, locale);
+    if (onClick) onClick(event);
+  }
+  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.`');
+    }
+    prefetch = false;
+  }
+
+  // Somehow the types for `next/link` don't work as expected
+  // when `moduleResolution: "nodenext"` is used.
+  const Link = NextLink;
+  return /*#__PURE__*/jsx(Link, {
+    ref: ref,
+    href: href,
+    hrefLang: isChangingLocale ? locale : undefined,
+    onClick: onLinkClick,
+    prefetch: prefetch,
+    ...rest
+  });
+}
+var BaseLink$1 = /*#__PURE__*/forwardRef(BaseLink);
+
+export { BaseLink$1 as default };

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

@@ -0,0 +1,105 @@
+import { redirect, permanentRedirect } from 'next/navigation';
+import { forwardRef } from 'react';
+import { receiveRoutingConfig } from '../../routing/config.js';
+import use from '../../shared/use.js';
+import { isLocalizableHref, isPromise } from '../../shared/utils.js';
+import BaseLink from './BaseLink.js';
+import { validateReceivedConfig, serializeSearchParams, compileLocalizedPathname, applyPathnamePrefix, normalizeNameOrNameWithParams } from './utils.js';
+import { jsx } from 'react/jsx-runtime';
+
+/**
+ * Shared implementations for `react-server` and `react-client`
+ */
+function createSharedNavigationFns(getLocale, routing) {
+  const config = receiveRoutingConfig(routing || {});
+  {
+    validateReceivedConfig(config);
+  }
+  const pathnames = config.pathnames;
+  function Link({
+    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 = isLocalizableHref(href);
+    const localePromiseOrValue = getLocale();
+    const curLocale = isPromise(localePromiseOrValue) ? use(localePromiseOrValue) : localePromiseOrValue;
+    const finalPathname = isLocalizable ? getPathname({
+      locale: locale || curLocale,
+      // @ts-expect-error -- This is ok
+      href: pathnames == null ? pathname : {
+        pathname,
+        params
+      },
+      // Always include a prefix when changing locales
+      forcePrefix: locale != null || undefined
+    }) : pathname;
+    return /*#__PURE__*/jsx(BaseLink, {
+      ref: ref
+      // @ts-expect-error -- This is ok
+      ,
+      href: typeof href === 'object' ? {
+        ...href,
+        pathname: finalPathname
+      } : finalPathname,
+      locale: locale,
+      localeCookie: config.localeCookie,
+      ...rest
+    });
+  }
+  const LinkWithRef = /*#__PURE__*/forwardRef(Link);
+  function getPathname(args) {
+    const {
+      forcePrefix,
+      href,
+      locale
+    } = args;
+    let pathname;
+    if (pathnames == null) {
+      if (typeof href === 'object') {
+        pathname = href.pathname;
+        if (href.query) {
+          pathname += serializeSearchParams(href.query);
+        }
+      } else {
+        pathname = href;
+      }
+    } else {
+      pathname = compileLocalizedPathname({
+        locale,
+        // @ts-expect-error -- This is ok
+        ...normalizeNameOrNameWithParams(href),
+        // @ts-expect-error -- This is ok
+        pathnames: config.pathnames
+      });
+    }
+    return applyPathnamePrefix(pathname, locale, config, forcePrefix);
+  }
+  function getRedirectFn(fn) {
+    /** @see https://next-intl.dev/docs/routing/navigation#redirect */
+    return function redirectFn(args, ...rest) {
+      return fn(getPathname(args), ...rest);
+    };
+  }
+  const redirect$1 = getRedirectFn(redirect);
+  const permanentRedirect$1 = getRedirectFn(permanentRedirect);
+  return {
+    config,
+    Link: LinkWithRef,
+    redirect: redirect$1,
+    permanentRedirect: permanentRedirect$1,
+    getPathname
+  };
+}
+
+export { createSharedNavigationFns as default };

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

@@ -0,0 +1,47 @@
+import { getBasePath } from './utils.js';
+
+/**
+ * We have to keep the cookie value in sync as Next.js might
+ * skip a request to the server due to its router cache.
+ * See https://github.com/amannn/next-intl/issues/786.
+ */
+function syncLocaleCookie(localeCookie, pathname, locale, nextLocale) {
+  const isSwitchingLocale = nextLocale !== locale && nextLocale != null;
+  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) {
+    return;
+  }
+  const basePath = getBasePath(pathname);
+  const hasBasePath = basePath !== '';
+  const defaultPath = hasBasePath ? basePath : '/';
+  const {
+    name,
+    ...rest
+  } = localeCookie;
+  if (!rest.path) {
+    rest.path = defaultPath;
+  }
+  let localeCookieString = `${name}=${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 += `${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 = localeCookieString;
+}
+
+export { syncLocaleCookie as default };

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

@@ -0,0 +1,165 @@
+import { getSortedPathnames, matchesPathname, isLocalizableHref, prefixPathname, getLocalizedTemplate, normalizeTrailingSlash, getLocalePrefix } from '../../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) {
+  return typeof href === 'string' ? {
+    pathname: href
+  } : href;
+}
+function serializeSearchParams(searchParams) {
+  function serializeValue(value) {
+    return String(value);
+  }
+  const urlSearchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(searchParams)) {
+    if (Array.isArray(value)) {
+      value.forEach(cur => {
+        urlSearchParams.append(key, serializeValue(cur));
+      });
+    } else {
+      urlSearchParams.set(key, serializeValue(value));
+    }
+  }
+  return '?' + urlSearchParams.toString();
+}
+function compileLocalizedPathname({
+  pathname,
+  locale,
+  params,
+  pathnames,
+  query
+}) {
+  function compilePath(value) {
+    const pathnameConfig = pathnames[value];
+    let compiled;
+    if (pathnameConfig) {
+      const template = getLocalizedTemplate(pathnameConfig, locale, value);
+      compiled = template;
+      if (params) {
+        Object.entries(params).forEach(([key, paramValue]) => {
+          let regexp, replacer;
+          if (Array.isArray(paramValue)) {
+            regexp = `(\\[)?\\[...${key}\\](\\])?`;
+            replacer = paramValue.map(v => String(v)).join('/');
+          } else {
+            regexp = `\\[${key}\\]`;
+            replacer = String(paramValue);
+          }
+          compiled = compiled.replace(new RegExp(regexp, 'g'), replacer);
+        });
+      }
+
+      // Clean up optional catch-all segments that were not replaced
+      compiled = compiled.replace(/\[\[\.\.\..+\]\]/g, '');
+      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: ${template}\nParams: ${JSON.stringify(params)}`);
+      }
+      compiled = encodePathname(compiled);
+    } else {
+      // Unknown pathnames
+      compiled = value;
+    }
+    compiled = normalizeTrailingSlash(compiled);
+    if (query) {
+      // This also encodes non-ASCII characters by
+      // using `new URLSearchParams()` internally
+      compiled += serializeSearchParams(query);
+    }
+    return compiled;
+  }
+  if (typeof pathname === 'string') {
+    return compilePath(pathname);
+  } else {
+    const {
+      pathname: internalPathname,
+      ...rest
+    } = pathname;
+    const compiled = compilePath(internalPathname);
+    const result = {
+      ...rest,
+      pathname: compiled
+    };
+    return result;
+  }
+}
+function encodePathname(pathname) {
+  // Generally, to comply with RFC 3986 and Google's best practices for URL structures
+  // (https://developers.google.com/search/docs/crawling-indexing/url-structure),
+  // we should always encode non-ASCII characters.
+  //
+  // There are two places where next-intl interacts with potentially non-ASCII URLs:
+  // 1. Middleware: When mapping a localized pathname to a non-localized pathname internally
+  // 2. Navigation APIs: When generating a URLs to be used for <Link /> & friends
+  //
+  // Next.js normalizes incoming pathnames to always be encoded, therefore we can safely
+  // decode them there (see middleware.tsx). On the other hand, Next.js doesn't consistently
+  // encode non-ASCII characters that are passed to navigation APIs:
+  // 1. <Link /> doesn't encode non-ASCII characters
+  // 2. useRouter() uses `new URL()` internally, which will encode—but only if necessary
+  // 3. redirect() uses useRouter() on the client, but on the server side only
+  //    assigns the location header without encoding.
+  //
+  // In addition to this, for getPathname() we need to encode non-ASCII characters.
+  //
+  // Therefore, the bottom line is that next-intl should take care of encoding non-ASCII
+  // characters in all cases, but can rely on `new URL()` to not double-encode characters.
+  return new URL(pathname, 'http://l').pathname;
+}
+function getRoute(locale, pathname, 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 (matchesPathname(localizedPathname, decoded)) {
+        return internalPathname;
+      }
+    } else {
+      if (matchesPathname(getLocalizedTemplate(localizedPathnamesOrPathname, locale, internalPathname), decoded)) {
+        return internalPathname;
+      }
+    }
+  }
+  return pathname;
+}
+function getBasePath(pathname, windowPathname = window.location.pathname) {
+  if (pathname === '/') {
+    return windowPathname;
+  } else {
+    return windowPathname.replace(pathname, '');
+  }
+}
+function applyPathnamePrefix(pathname, locale, routing, force) {
+  const {
+    mode
+  } = routing.localePrefix;
+  let shouldPrefix;
+  if (force !== undefined) {
+    shouldPrefix = force;
+  } else if (isLocalizableHref(pathname)) {
+    if (mode === 'always') {
+      shouldPrefix = true;
+    } else if (mode === 'as-needed') {
+      shouldPrefix = routing.domains ?
+      // Since locales are unique per domain, any locale that is a
+      // default locale of a domain doesn't require a prefix
+      !routing.domains.some(cur => cur.defaultLocale === locale) : locale !== routing.defaultLocale;
+    }
+  }
+  return shouldPrefix ? prefixPathname(getLocalePrefix(locale, routing.localePrefix), pathname) : pathname;
+}
+function validateReceivedConfig(config) {
+  if (config.localePrefix?.mode === 'as-needed' && !('defaultLocale' in config)) {
+    throw new Error("`localePrefix: 'as-needed' requires a `defaultLocale`.");
+  }
+}
+
+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/config.js

@@ -0,0 +1,10 @@
+// Avoid rollup's `replace` plugin to compile this away
+const nodeEnvKey = 'NODE_ENV'.trim();
+
+// We avoid reading `argv.includes('dev')` related to
+// https://github.com/amannn/next-intl/issues/2006
+const isDevelopment = process.env[nodeEnvKey] === 'development';
+const isNextBuild = process.argv.includes('build');
+const isDevelopmentOrNextBuild = isDevelopment || isNextBuild;
+
+export { isDevelopment, isDevelopmentOrNextBuild, isNextBuild };

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

@@ -0,0 +1,26 @@
+import initExtractionCompiler from './extractor/initExtractionCompiler.js';
+import getNextConfig from './getNextConfig.js';
+import { warn } from './utils.js';
+import createMessagesDeclaration from './declaration/createMessagesDeclaration.js';
+
+function initPlugin(pluginConfig, nextConfig) {
+  if (nextConfig?.i18n != null) {
+    warn("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.dev/examples#app-router-migration\n");
+  }
+  const messagesPathOrPaths = pluginConfig.experimental?.createMessagesDeclaration;
+  if (messagesPathOrPaths) {
+    createMessagesDeclaration(typeof messagesPathOrPaths === 'string' ? [messagesPathOrPaths] : messagesPathOrPaths);
+  }
+  initExtractionCompiler(pluginConfig);
+  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/declaration/createMessagesDeclaration.js

@@ -0,0 +1,70 @@
+import fs from 'fs';
+import path from 'path';
+import { once, throwError } from '../utils.js';
+import watchFile from '../watchFile.js';
+
+const runOnce = once('_NEXT_INTL_COMPILE_MESSAGES');
+function createMessagesDeclaration(messagesPaths) {
+  // Instead of running _only_ in certain cases, it's
+  // safer to _avoid_ running for certain known cases.
+  // https://github.com/amannn/next-intl/issues/2006
+  const shouldBailOut = ['info', 'start'
+
+  // Note: These commands don't consult the
+  // Next.js config, so we can't detect them here.
+  // - telemetry
+  // - lint
+  //
+  // What remains are:
+  // - dev
+  // - build
+  // - typegen
+  ].some(arg => process.argv.includes(arg));
+  if (shouldBailOut) {
+    return;
+  }
+  runOnce(() => {
+    for (const messagesPath of messagesPaths) {
+      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}`);
+      }
+
+      // Keep this as a runtime check and don't replace
+      // this with a constant during the build process
+      const env = process.env['NODE_ENV'.trim()];
+      compileDeclaration(messagesPath);
+      if (env === 'development') {
+        startWatching(messagesPath);
+      }
+    }
+  });
+}
+function startWatching(messagesPath) {
+  const watcher = watchFile(messagesPath, () => {
+    compileDeclaration(messagesPath, true);
+  });
+  process.on('exit', () => {
+    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.dev/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 };