next-intl 2.22.0 → 2.22.2

package/src/middleware/middleware.tsx

@@ -1,206 +0,0 @@
-import {NextRequest, NextResponse} from 'next/server';
-import {COOKIE_LOCALE_NAME} from '../shared/constants';
-import MiddlewareConfig, {
-  MiddlewareConfigWithDefaults
-} from './NextIntlMiddlewareConfig';
-import getAlternateLinksHeaderValue from './getAlternateLinksHeaderValue';
-import resolveLocale from './resolveLocale';
-import {
-  getBestMatchingDomain,
-  getLocaleFromPathname,
-  isLocaleSupportedOnDomain
-} from './utils';
-
-const ROOT_URL = '/';
-
-function receiveConfig(config: MiddlewareConfig) {
-  const result: MiddlewareConfigWithDefaults = {
-    ...config,
-    alternateLinks: config.alternateLinks ?? true,
-    localePrefix: config.localePrefix ?? 'as-needed',
-    localeDetection: config.localeDetection ?? true
-  };
-
-  return result;
-}
-
-export default function createMiddleware(config: MiddlewareConfig) {
-  const configWithDefaults = receiveConfig(config);
-
-  // Currently only in use to enable a seamless upgrade path from the
-  // `{createIntlMiddleware} from 'next-intl/server'` API.
-  const matcher: Array<string> | undefined = (config as any)._matcher;
-
-  return function middleware(request: NextRequest) {
-    const matches =
-      !matcher ||
-      matcher.some((pattern) => request.nextUrl.pathname.match(pattern));
-    if (!matches) return NextResponse.next();
-
-    const {domain, locale} = resolveLocale(
-      configWithDefaults,
-      request.headers,
-      request.cookies,
-      request.nextUrl.pathname
-    );
-
-    const isRoot = request.nextUrl.pathname === ROOT_URL;
-    const hasOutdatedCookie =
-      request.cookies.get(COOKIE_LOCALE_NAME)?.value !== locale;
-    const hasMatchedDefaultLocale = domain
-      ? domain.defaultLocale === locale
-      : locale === configWithDefaults.defaultLocale;
-
-    const domainConfigs =
-      configWithDefaults.domains?.filter((curDomain) =>
-        isLocaleSupportedOnDomain(locale, curDomain)
-      ) || [];
-    const hasUnknownHost = configWithDefaults.domains != null && !domain;
-
-    function getResponseInit() {
-      const responseInit = {
-        request: {
-          headers: request.headers
-        }
-      };
-
-      return responseInit;
-    }
-
-    function rewrite(url: string) {
-      return NextResponse.rewrite(new URL(url, request.url), getResponseInit());
-    }
-
-    function next() {
-      return NextResponse.next(getResponseInit());
-    }
-
-    function redirect(url: string, host?: string) {
-      const urlObj = new URL(url, request.url);
-
-      if (domainConfigs.length > 0) {
-        if (!host) {
-          const bestMatchingDomain = getBestMatchingDomain(
-            domain,
-            locale,
-            domainConfigs
-          );
-
-          if (bestMatchingDomain) {
-            host = bestMatchingDomain.domain;
-
-            if (
-              bestMatchingDomain.defaultLocale === locale &&
-              configWithDefaults.localePrefix === 'as-needed'
-            ) {
-              urlObj.pathname = urlObj.pathname.replace(`/${locale}`, '');
-            }
-          }
-        }
-      }
-
-      if (host) {
-        urlObj.host = host;
-      }
-
-      return NextResponse.redirect(urlObj.toString());
-    }
-
-    let response;
-    if (isRoot) {
-      let pathWithSearch = `/${locale}`;
-      if (request.nextUrl.search) {
-        pathWithSearch += request.nextUrl.search;
-      }
-
-      if (
-        configWithDefaults.localePrefix === 'never' ||
-        (hasMatchedDefaultLocale &&
-          configWithDefaults.localePrefix === 'as-needed')
-      ) {
-        response = rewrite(pathWithSearch);
-      } else {
-        response = redirect(pathWithSearch);
-      }
-    } else {
-      const pathLocaleCandidate = getLocaleFromPathname(
-        request.nextUrl.pathname
-      );
-      const pathLocale = configWithDefaults.locales.includes(
-        pathLocaleCandidate
-      )
-        ? pathLocaleCandidate
-        : undefined;
-      const hasLocalePrefix = pathLocale != null;
-
-      let pathWithSearch = request.nextUrl.pathname;
-      if (request.nextUrl.search) {
-        pathWithSearch += request.nextUrl.search;
-      }
-
-      if (hasLocalePrefix) {
-        const basePath = pathWithSearch.replace(`/${pathLocale}`, '') || '/';
-
-        if (configWithDefaults.localePrefix === 'never') {
-          response = redirect(basePath);
-        } else if (pathLocale === locale) {
-          if (
-            hasMatchedDefaultLocale &&
-            configWithDefaults.localePrefix === 'as-needed'
-          ) {
-            response = redirect(basePath);
-          } else {
-            if (configWithDefaults.domains) {
-              const pathDomain = getBestMatchingDomain(
-                domain,
-                pathLocale,
-                domainConfigs
-              );
-
-              if (domain?.domain !== pathDomain?.domain && !hasUnknownHost) {
-                response = redirect(basePath, pathDomain?.domain);
-              } else {
-                response = next();
-              }
-            } else {
-              response = next();
-            }
-          }
-        } else {
-          response = redirect(`/${locale}${basePath}`);
-        }
-      } else {
-        if (
-          configWithDefaults.localePrefix === 'never' ||
-          (hasMatchedDefaultLocale &&
-            (configWithDefaults.localePrefix === 'as-needed' ||
-              configWithDefaults.domains))
-        ) {
-          response = rewrite(`/${locale}${pathWithSearch}`);
-        } else {
-          response = redirect(`/${locale}${pathWithSearch}`);
-        }
-      }
-    }
-
-    if (hasOutdatedCookie) {
-      response.cookies.set(COOKIE_LOCALE_NAME, locale, {
-        sameSite: 'strict',
-        maxAge: 31536000 // 1 year
-      });
-    }
-
-    if (
-      configWithDefaults.localePrefix !== 'never' &&
-      configWithDefaults.alternateLinks &&
-      configWithDefaults.locales.length > 1
-    ) {
-      response.headers.set(
-        'Link',
-        getAlternateLinksHeaderValue(configWithDefaults, request)
-      );
-    }
-
-    return response;
-  };
-}

package/src/middleware/resolveLocale.tsx

@@ -1,151 +0,0 @@
-import {match} from '@formatjs/intl-localematcher';
-import Negotiator from 'negotiator';
-import {RequestCookies} from 'next/dist/server/web/spec-extension/cookies';
-import {COOKIE_LOCALE_NAME} from '../shared/constants';
-import {
-  DomainConfig,
-  MiddlewareConfigWithDefaults
-} from './NextIntlMiddlewareConfig';
-import {
-  getLocaleFromPathname,
-  getHost,
-  isLocaleSupportedOnDomain
-} from './utils';
-
-function findDomainFromHost(
-  requestHeaders: Headers,
-  domains: Array<DomainConfig>
-) {
-  let host = getHost(requestHeaders);
-
-  // Remove port (easier for local development)
-  host = host?.replace(/:\d+$/, '');
-
-  if (host && domains) {
-    return domains.find((cur) => cur.domain === host);
-  }
-
-  return undefined;
-}
-
-function getAcceptLanguageLocale(
-  requestHeaders: Headers,
-  locales: Array<string>,
-  defaultLocale: string
-) {
-  let locale;
-
-  const languages = new Negotiator({
-    headers: {
-      'accept-language': requestHeaders.get('accept-language') || undefined
-    }
-  }).languages();
-  try {
-    locale = match(languages, locales, defaultLocale);
-  } catch (e) {
-    // Invalid language
-  }
-
-  return locale;
-}
-
-function resolveLocaleFromPrefix(
-  {defaultLocale, localeDetection, locales}: MiddlewareConfigWithDefaults,
-  requestHeaders: Headers,
-  requestCookies: RequestCookies,
-  pathname: string
-) {
-  let locale;
-
-  // Prio 1: Use route prefix
-  if (pathname) {
-    const pathLocale = getLocaleFromPathname(pathname);
-    if (locales.includes(pathLocale)) {
-      locale = pathLocale;
-    }
-  }
-
-  // Prio 2: Use existing cookie
-  if (!locale && localeDetection && requestCookies) {
-    if (requestCookies.has(COOKIE_LOCALE_NAME)) {
-      const value = requestCookies.get(COOKIE_LOCALE_NAME)?.value;
-      if (value && locales.includes(value)) {
-        locale = value;
-      }
-    }
-  }
-
-  // Prio 3: Use the `accept-language` header
-  if (!locale && localeDetection && requestHeaders) {
-    locale = getAcceptLanguageLocale(requestHeaders, locales, defaultLocale);
-  }
-
-  // Prio 4: Use default locale
-  if (!locale) {
-    locale = defaultLocale;
-  }
-
-  return locale;
-}
-
-function resolveLocaleFromDomain(
-  config: MiddlewareConfigWithDefaults,
-  requestHeaders: Headers,
-  requestCookies: RequestCookies,
-  pathname: string
-) {
-  const {domains} = config;
-
-  const localeFromPrefixStrategy = resolveLocaleFromPrefix(
-    config,
-    requestHeaders,
-    requestCookies,
-    pathname
-  );
-
-  // Prio 1: Use a domain
-  if (domains) {
-    const domain = findDomainFromHost(requestHeaders, domains);
-    const hasLocalePrefix =
-      pathname && pathname.startsWith(`/${localeFromPrefixStrategy}`);
-
-    if (domain) {
-      return {
-        locale:
-          isLocaleSupportedOnDomain(localeFromPrefixStrategy, domain) ||
-          hasLocalePrefix
-            ? localeFromPrefixStrategy
-            : domain.defaultLocale,
-        domain
-      };
-    }
-  }
-
-  // Prio 2: Use prefix strategy
-  return {locale: localeFromPrefixStrategy};
-}
-
-export default function resolveLocale(
-  config: MiddlewareConfigWithDefaults,
-  requestHeaders: Headers,
-  requestCookies: RequestCookies,
-  pathname: string
-): {locale: string; domain?: DomainConfig} {
-  if (config.domains) {
-    return resolveLocaleFromDomain(
-      config,
-      requestHeaders,
-      requestCookies,
-      pathname
-    );
-  } else {
-    return {
-      locale: resolveLocaleFromPrefix(
-        config,
-        requestHeaders,
-        requestCookies,
-        pathname
-      )
-    };
-  }
-}

package/src/middleware/utils.tsx

@@ -1,61 +0,0 @@
-import {DomainConfig} from './NextIntlMiddlewareConfig';
-
-export function getLocaleFromPathname(pathname: string) {
-  return pathname.split('/')[1];
-}
-
-export function getHost(requestHeaders: Headers) {
-  return (
-    requestHeaders.get('x-forwarded-host') ??
-    requestHeaders.get('host') ??
-    undefined
-  );
-}
-
-export function isLocaleSupportedOnDomain(
-  locale: string,
-  domain: DomainConfig
-) {
-  return (
-    domain.defaultLocale === locale ||
-    !domain.locales ||
-    domain.locales.includes(locale)
-  );
-}
-
-export function getBestMatchingDomain(
-  curHostDomain: DomainConfig | undefined,
-  locale: string,
-  domainConfigs: Array<DomainConfig>
-) {
-  let domainConfig;
-
-  // Prio 1: Stay on current domain
-  if (curHostDomain && isLocaleSupportedOnDomain(locale, curHostDomain)) {
-    domainConfig = curHostDomain;
-  }
-
-  // Prio 2: Use alternative domain with matching default locale
-  if (!domainConfig) {
-    domainConfig = domainConfigs.find((cur) => cur.defaultLocale === locale);
-  }
-
-  // Prio 3: Use alternative domain with restricted matching locale
-  if (!domainConfig) {
-    domainConfig = domainConfigs.find(
-      (cur) => cur.locales != null && cur.locales.includes(locale)
-    );
-  }
-
-  // Prio 4: Stay on the current domain if it supports all locales
-  if (!domainConfig && curHostDomain?.locales == null) {
-    domainConfig = curHostDomain;
-  }
-
-  // Prio 5: Use alternative domain that supports all locales
-  if (!domainConfig) {
-    domainConfig = domainConfigs.find((cur) => !cur.locales);
-  }
-
-  return domainConfig;
-}

package/src/react-client/index.tsx

@@ -1,15 +0,0 @@
-/**
- * This is the main entry file when non-'react-server'
- * environments import from 'next-intl'.
- *
- * Maintainer notes:
- * - Make sure this mirrors the API from 'react-server'.
- * - Make sure everything exported from this module is
- *   supported in all Next.js versions that are supported.
- */
-
-export * from 'use-intl';
-export {default as NextIntlClientProvider} from '../shared/NextIntlClientProvider';
-
-// Legacy export (TBD if we'll deprecate this in favour of `NextIntlClientProvider`)
-export {default as NextIntlProvider} from '../shared/NextIntlClientProvider';

package/src/react-server/index.tsx

@@ -1,29 +0,0 @@
-/**
- * This is the main entry file when 'react-server' environments
- * (i.e. RSC) import from 'next-intl'. Currently we export everything
- * from `use-intl` core, but React-APIs are stubbed out.
- *
- * Make sure this mirrors the API from '../react-client'.
- */
-
-export * from 'use-intl/dist/src/core';
-export {default as NextIntlClientProvider} from '../shared/NextIntlClientProvider';
-
-function notSupported() {
-  throw new Error(
-    `The React APIs of next-intl are currently not available in Server Components.
-
-You can try one of these options:
-1. Try out the Server Components beta, see https://next-intl-docs.vercel.app/docs/getting-started
-2. Use the core library as a stopgap solution, see https://next-intl-docs.vercel.app/docs/environments/core-library
-`
-  );
-}
-
-export const IntlProvider = notSupported;
-export const useTranslations = notSupported;
-export const useIntl = notSupported;
-export const useLocale = notSupported;
-export const useNow = notSupported;
-export const useTimeZone = notSupported;
-export const Link = notSupported;

package/src/server/index.tsx

@@ -1,34 +0,0 @@
-/**
- * Server-only APIs available via `next-intl/server`.
- */
-
-import createMiddleware_ from '../middleware';
-import MiddlewareConfig from '../middleware/NextIntlMiddlewareConfig';
-
-let hasWarned = false;
-/** @deprecated Should be imported as `import createMiddleware from 'next-intl/middleware', not from `next-intl/server`. */
-export function createIntlMiddleware(config: MiddlewareConfig) {
-  if (!hasWarned) {
-    hasWarned = true;
-    console.warn(
-      `
-Importing \`createMiddleware\` from \`next-intl/server\` is deprecated. Please update the import and add a \`matcher\`:
-
-  // middleware.ts
-  import createMiddleware from 'next-intl/middleware';
-
-  // ...
-
-  export const config = {
-    // Skip all paths that should not be internationalized
-    matcher: ['/((?!api|_next|.*\\\\..*).*)']
-  };
-`
-    );
-  }
-  return createMiddleware_({
-    ...config,
-    // @ts-expect-error
-    _matcher: ['/((?!api|_next|.*\\..*).*)']
-  });
-}

package/src/shared/BaseLink.tsx

@@ -1,57 +0,0 @@
-'use client';
-
-import NextLink from 'next/link';
-import {usePathname} from 'next/navigation';
-import React, {ComponentProps, forwardRef, useEffect, useState} from 'react';
-import useClientLocale from '../client/useClientLocale';
-import {isLocalHref, localizeHref, prefixHref} from './utils';
-
-type Props = Omit<ComponentProps<typeof NextLink>, 'locale'> & {
-  locale: string;
-};
-
-function BaseLink({href, locale, prefetch, ...rest}: Props, ref: Props['ref']) {
-  // The types aren't entirely correct here. Outside of Next.js
-  // `useParams` can be called, but the return type is `null`.
-  const pathname = usePathname() as ReturnType<typeof usePathname> | null;
-
-  const defaultLocale = useClientLocale();
-  const isChangingLocale = locale !== defaultLocale;
-
-  const [localizedHref, setLocalizedHref] = useState<typeof href>(() =>
-    isLocalHref(href) && locale
-      ? // Potentially the href shouldn't be prefixed, but to determine this we
-        // need a) the default locale and b) the information if we use prefixed
-        // routing. During the server side render (both in RSC as well as SSR),
-        // we don't have this information. 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.
-        prefixHref(href, locale)
-      : href
-  );
-
-  useEffect(() => {
-    if (!pathname) return;
-
-    setLocalizedHref(
-      localizeHref(href, locale, defaultLocale, pathname ?? undefined)
-    );
-  }, [defaultLocale, href, locale, pathname]);
-
-  if (isChangingLocale) {
-    if (prefetch && process.env.NODE_ENV !== 'production') {
-      console.error(
-        'The `prefetch` prop is currently not supported when using the `locale` prop on `Link` to switch the locale.`'
-      );
-    }
-    prefetch = false;
-  }
-
-  return (
-    <NextLink ref={ref} href={localizedHref} prefetch={prefetch} {...rest} />
-  );
-}
-
-export default forwardRef(BaseLink);

package/src/shared/NextIntlClientProvider.tsx

@@ -1,54 +0,0 @@
-'use client';
-
-import {useRouter} from 'next/router';
-import React, {ComponentProps} from 'react';
-import {IntlProvider} from 'use-intl';
-
-type Props = Omit<ComponentProps<typeof IntlProvider>, 'locale' | 'now'> & {
-  locale?: string;
-  /** If a string is supplied, make sure this conforms to the ISO 8601 format (YYYY-MM-DDTHH:mm:ss.sssZ */
-  now?: Date | string;
-};
-
-export default function NextIntlClientProvider({
-  children,
-  locale,
-  now,
-  ...rest
-}: Props) {
-  let router;
-  try {
-    // Reading from context is practically ok to do conditionally
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    router = useRouter();
-  } catch (error) {
-    // Calling `useRouter` is not supported in the app folder
-  }
-
-  // The router can be undefined if used in a context outside
-  // of Next.js (e.g. unit tests, Storybook, ...)
-  if (!locale && router) {
-    locale = router.locale;
-  }
-
-  // Currently RSC serialize dates to strings, therefore make sure we have
-  // a date object. We might be able to remove this once more types have
-  // first-class serialization support (https://github.com/facebook/react/issues/25687)
-  if (typeof now === 'string') {
-    now = new Date(now);
-  }
-
-  if (!locale) {
-    throw new Error(
-      process.env.NODE_ENV !== 'production'
-        ? "Couldn't determine locale. Please pass an explicit `locale` prop the provider, or if you're using the `pages` folder, use internationalized routing (https://nextjs.org/docs/advanced-features/i18n-routing)."
-        : undefined
-    );
-  }
-
-  return (
-    <IntlProvider locale={locale} now={now} {...rest}>
-      {children}
-    </IntlProvider>
-  );
-}

package/src/shared/constants.tsx

@@ -1,6 +0,0 @@
-// Reuse the legacy cookie name
-// https://nextjs.org/docs/advanced-features/i18n-routing#leveraging-the-next_locale-cookie
-export const COOKIE_LOCALE_NAME = 'NEXT_LOCALE';
-
-// In a URL like "/en-US/about", the locale segment is "en-US"
-export const LOCALE_SEGMENT_NAME = 'locale';