next-intl 2.22.0 → 2.22.2

package/dist/development/navigation/createLocalizedPathnamesNavigation.js

@@ -0,0 +1,135 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_virtual/_rollupPluginBabelHelpers.js');
+var React = require('react');
+var useLocale = require('../react-client/useLocale.js');
+var BaseLink = require('./BaseLink.js');
+var baseRedirect = require('./baseRedirect.js');
+var useBasePathname = require('./useBasePathname.js');
+var useBaseRouter = require('./useBaseRouter.js');
+var utils = require('./utils.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+function createLocalizedPathnamesNavigation(_ref) {
+  let {
+    locales,
+    pathnames
+  } = _ref;
+  function useTypedLocale() {
+    const locale = useLocale.default();
+    const isValid = locales.includes(locale);
+    if (!isValid) {
+      throw new Error("Unknown locale encountered: \"".concat(locale, "\". Make sure to validate the locale in `app/[locale]/layout.tsx`.") );
+    }
+    return locale;
+  }
+  function Link(_ref2, ref) {
+    let {
+      href,
+      locale,
+      ...rest
+    } = _ref2;
+    const defaultLocale = useTypedLocale();
+    const finalLocale = locale || defaultLocale;
+    return /*#__PURE__*/React__default.default.createElement(BaseLink.default, _rollupPluginBabelHelpers.extends({
+      ref: ref,
+      href: utils.compileLocalizedPathname({
+        locale: finalLocale,
+        // @ts-expect-error -- This is ok
+        pathname: href,
+        // @ts-expect-error -- This is ok
+        params: typeof href === 'object' ? href.params : undefined,
+        pathnames
+      }),
+      locale: locale
+    }, rest));
+  }
+  const LinkWithRef = /*#__PURE__*/React.forwardRef(Link);
+  LinkWithRef.displayName = 'Link';
+  function redirect(href) {
+    // eslint-disable-next-line react-hooks/rules-of-hooks -- Reading from context here is fine, since `redirect` should be called during render
+    const locale = useTypedLocale();
+    const resolvedHref = getPathname({
+      href,
+      locale
+    });
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    return baseRedirect.default(resolvedHref, ...args);
+  }
+  function useRouter() {
+    const baseRouter = useBaseRouter.default();
+    const defaultLocale = useTypedLocale();
+    return {
+      ...baseRouter,
+      push(href) {
+        var _args$;
+        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+          args[_key2 - 1] = arguments[_key2];
+        }
+        const resolvedHref = getPathname({
+          href,
+          locale: ((_args$ = args[0]) === null || _args$ === void 0 ? void 0 : _args$.locale) || defaultLocale
+        });
+        return baseRouter.push(resolvedHref, ...args);
+      },
+      replace(href) {
+        var _args$2;
+        for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+          args[_key3 - 1] = arguments[_key3];
+        }
+        const resolvedHref = getPathname({
+          href,
+          locale: ((_args$2 = args[0]) === null || _args$2 === void 0 ? void 0 : _args$2.locale) || defaultLocale
+        });
+        return baseRouter.replace(resolvedHref, ...args);
+      },
+      prefetch(href) {
+        var _args$3;
+        for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+          args[_key4 - 1] = arguments[_key4];
+        }
+        const resolvedHref = getPathname({
+          href,
+          locale: ((_args$3 = args[0]) === null || _args$3 === void 0 ? void 0 : _args$3.locale) || defaultLocale
+        });
+        return baseRouter.prefetch(resolvedHref, ...args);
+      }
+    };
+  }
+  function usePathname() {
+    const pathname = useBasePathname.default();
+    const locale = useTypedLocale();
+    return utils.getRoute({
+      pathname,
+      locale,
+      pathnames
+    });
+  }
+  function getPathname(_ref3) {
+    let {
+      href,
+      locale
+    } = _ref3;
+    return utils.compileLocalizedPathname({
+      ...utils.normalizeNameOrNameWithParams(href),
+      locale,
+      pathnames
+    });
+  }
+  return {
+    Link: LinkWithRef,
+    redirect,
+    usePathname,
+    useRouter,
+    getPathname
+  };
+}
+
+exports.default = createLocalizedPathnamesNavigation;

package/dist/development/navigation/createSharedPathnamesNavigation.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var BaseLink = require('./BaseLink.js');
+var baseRedirect = require('./baseRedirect.js');
+var useBasePathname = require('./useBasePathname.js');
+var useBaseRouter = require('./useBaseRouter.js');
+
+function createSharedPathnamesNavigation(opts) {
+  return {
+    Link: BaseLink.default,
+    redirect: baseRedirect.default,
+    usePathname: useBasePathname.default,
+    useRouter: useBaseRouter.default
+  };
+}
+
+exports.default = createSharedPathnamesNavigation;

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

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.js');
+var React = require('react');
+var useLocale = require('../../react-server/useLocale.js');
+var BaseLinkWithLocale = require('../../shared/BaseLinkWithLocale.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+function BaseLink(_ref) {
+  let {
+    locale,
+    ...rest
+  } = _ref;
+  const defaultLocale = useLocale.default();
+  return /*#__PURE__*/React__default.default.createElement(BaseLinkWithLocale.default, _rollupPluginBabelHelpers.extends({
+    locale: locale || defaultLocale
+  }, rest));
+}
+
+exports.default = BaseLink;

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

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var RequestLocale = require('../../server/RequestLocale.js');
+var redirectWithLocale = require('../../shared/redirectWithLocale.js');
+
+function baseRedirect(pathname) {
+  const locale = RequestLocale.getRequestLocale();
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+  return redirectWithLocale.default(pathname, locale, ...args);
+}
+
+exports.default = baseRedirect;

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

@@ -0,0 +1,77 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.js');
+var React = require('react');
+var RequestLocale = require('../../server/RequestLocale.js');
+var utils = require('../utils.js');
+var BaseLink = require('./BaseLink.js');
+var baseRedirect = require('./baseRedirect.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+function createLocalizedPathnamesNavigation(_ref) {
+  let {
+    locales,
+    pathnames
+  } = _ref;
+  function Link(_ref2) {
+    let {
+      href,
+      locale,
+      ...rest
+    } = _ref2;
+    const defaultLocale = RequestLocale.getRequestLocale();
+    const finalLocale = locale || defaultLocale;
+    return /*#__PURE__*/React__default.default.createElement(BaseLink.default, _rollupPluginBabelHelpers.extends({
+      href: utils.compileLocalizedPathname({
+        locale: finalLocale,
+        // @ts-expect-error -- This is ok
+        pathname: href,
+        // @ts-expect-error -- This is ok
+        params: typeof href === 'object' ? href.params : undefined,
+        pathnames
+      }),
+      locale: locale
+    }, rest));
+  }
+  function redirect(href) {
+    const locale = RequestLocale.getRequestLocale();
+    const resolvedHref = getPathname({
+      href,
+      locale
+    });
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    return baseRedirect.default(resolvedHref, ...args);
+  }
+  function getPathname(_ref3) {
+    let {
+      href,
+      locale
+    } = _ref3;
+    return utils.compileLocalizedPathname({
+      ...utils.normalizeNameOrNameWithParams(href),
+      locale,
+      pathnames
+    });
+  }
+  function notSupported(message) {
+    return () => {
+      throw new Error("`".concat(message, "` is not supported in Server Components. You can use this hook if you convert the component to a Client Component."));
+    };
+  }
+  return {
+    Link,
+    redirect,
+    getPathname,
+    usePathname: notSupported('usePathname'),
+    useRouter: notSupported('useRouter')
+  };
+}
+
+exports.default = createLocalizedPathnamesNavigation;

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

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var BaseLink = require('./BaseLink.js');
+var baseRedirect = require('./baseRedirect.js');
+
+function createSharedPathnamesNavigation(opts) {
+  function notSupported(message) {
+    return () => {
+      throw new Error("`".concat(message, "` is not supported in Server Components. You can use this hook if you convert the component to a Client Component."));
+    };
+  }
+  return {
+    Link: BaseLink.default,
+    redirect: baseRedirect.default,
+    usePathname: notSupported('usePathname'),
+    useRouter: notSupported('useRouter')
+  };
+}
+
+exports.default = createSharedPathnamesNavigation;

package/dist/development/navigation/useBasePathname.js

@@ -0,0 +1,37 @@
+'use client';
+'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 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() {
+  // 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 locale = useLocale.default();
+  return React.useMemo(() => {
+    if (!pathname) return pathname;
+    const isPathnamePrefixed = utils.hasPathnamePrefixed(locale, pathname);
+    const unlocalizedPathname = isPathnamePrefixed ? utils.unlocalizePathname(pathname, locale) : pathname;
+    return unlocalizedPathname;
+  }, [locale, pathname]);
+}
+
+exports.default = useBasePathname;

package/dist/development/navigation/useBaseRouter.js

@@ -0,0 +1,76 @@
+'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 utils = require('../shared/utils.js');
+
+/**
+ * Returns a wrapped instance of `useRouter` from `next/navigation` that
+ * will automatically localize the `href` parameters it receives.
+ *
+ * @example
+ * ```tsx
+ * 'use client';
+ *
+ * import {useRouter} from 'next-intl/client';
+ *
+ * const router = useRouter();
+ *
+ * // When the user is on `/en`, the router will navigate to `/en/about`
+ * router.push('/about');
+ *
+ * // Optionally, you can switch the locale by passing the second argument
+ * router.push('/about', {locale: 'de'});
+ * ```
+ */
+function useBaseRouter() {
+  const router = navigation.useRouter();
+  const locale = useLocale.default();
+  return React.useMemo(() => {
+    function localize(href, nextLocale) {
+      return utils.localizeHref(href, nextLocale || locale, locale, window.location.pathname);
+    }
+    return {
+      ...router,
+      push(href, options) {
+        const {
+          locale: nextLocale,
+          ...rest
+        } = options || {};
+        const args = [localize(href, nextLocale)];
+        if (Object.keys(rest).length > 0) {
+          args.push(rest);
+        }
+        return router.push(...args);
+      },
+      replace(href, options) {
+        const {
+          locale: nextLocale,
+          ...rest
+        } = options || {};
+        const args = [localize(href, nextLocale)];
+        if (Object.keys(rest).length > 0) {
+          args.push(rest);
+        }
+        return router.replace(...args);
+      },
+      prefetch(href, options) {
+        const {
+          locale: nextLocale,
+          ...rest
+        } = options || {};
+        const args = [localize(href, nextLocale)];
+        if (Object.keys(rest).length > 0) {
+          // @ts-expect-error TypeScript thinks `rest` can be an empty object
+          args.push(rest);
+        }
+        return router.prefetch(...args);
+      }
+    };
+  }, [locale, router]);
+}
+
+exports.default = useBaseRouter;

package/dist/development/navigation/utils.js

@@ -0,0 +1,108 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('../shared/utils.js');
+
+// Minor false positive: A route that has both optional and
+// required params will allow optional params.
+function normalizeNameOrNameWithParams(href) {
+  // @ts-expect-error -- `extends string` in the generic unfortunately weakens the type
+  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(_ref) {
+  let {
+    pathname,
+    locale,
+    params,
+    pathnames,
+    query
+  } = _ref;
+  function getNamedPath(value) {
+    let namedPath = pathnames[value];
+    if (!namedPath) {
+      namedPath = value;
+    }
+    return namedPath;
+  }
+  function compilePath(namedPath) {
+    const template = typeof namedPath === 'string' ? namedPath : namedPath[locale];
+    let compiled = template;
+    if (params) {
+      Object.entries(params).forEach(_ref2 => {
+        let [key, value] = _ref2;
+        if (Array.isArray(value)) {
+          compiled = compiled.replace(new RegExp("(\\[)?\\[...".concat(key, "\\](\\])?"), 'g'), value.map(v => String(v)).join('/'));
+        } else {
+          compiled = compiled.replace("[".concat(key, "]"), String(value));
+        }
+      });
+    }
+    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: ".concat(template, "\nParams: ").concat(JSON.stringify(params)));
+    }
+    if (query) {
+      compiled += serializeSearchParams(query);
+    }
+    return compiled;
+  }
+  if (typeof pathname === 'string') {
+    const namedPath = getNamedPath(pathname);
+    const compiled = compilePath(namedPath);
+    return compiled;
+  } else {
+    const {
+      pathname: href,
+      ...rest
+    } = pathname;
+    const namedPath = getNamedPath(href);
+    const compiled = compilePath(namedPath);
+    const result = {
+      ...rest,
+      pathname: compiled
+    };
+    return result;
+  }
+}
+function getRoute(_ref3) {
+  var _Object$entries$find;
+  let {
+    locale,
+    pathname,
+    pathnames
+  } = _ref3;
+  const unlocalizedPathname = utils.unlocalizePathname(pathname, locale);
+  let template = (_Object$entries$find = Object.entries(pathnames).find(_ref4 => {
+    let [, routePath] = _ref4;
+    const routePathname = typeof routePath !== 'string' ? routePath[locale] : routePath;
+    return utils.matchesPathname(routePathname, unlocalizedPathname);
+  })) === null || _Object$entries$find === void 0 ? void 0 : _Object$entries$find[0];
+  if (!template) {
+    template = pathname;
+  }
+  return template;
+}
+
+exports.compileLocalizedPathname = compileLocalizedPathname;
+exports.getRoute = getRoute;
+exports.normalizeNameOrNameWithParams = normalizeNameOrNameWithParams;
+exports.serializeSearchParams = serializeSearchParams;

package/dist/development/navigation.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var createSharedPathnamesNavigation = require('./navigation/createSharedPathnamesNavigation.js');
+var createLocalizedPathnamesNavigation = require('./navigation/createLocalizedPathnamesNavigation.js');
+
+
+
+exports.createSharedPathnamesNavigation = createSharedPathnamesNavigation.default;
+exports.createLocalizedPathnamesNavigation = createLocalizedPathnamesNavigation.default;

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

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var createSharedPathnamesNavigation = require('./navigation/react-server/createSharedPathnamesNavigation.js');
+var createLocalizedPathnamesNavigation = require('./navigation/react-server/createLocalizedPathnamesNavigation.js');
+
+
+
+exports.createSharedPathnamesNavigation = createSharedPathnamesNavigation.default;
+exports.createLocalizedPathnamesNavigation = createLocalizedPathnamesNavigation.default;

package/dist/development/plugin.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+/* eslint-env node */
+
+function resolveI18nPath(cwd, providedPath) {
+  let i18nPath = providedPath;
+  if (i18nPath) {
+    i18nPath = path__default.default.resolve(i18nPath);
+    if (!fs__default.default.existsSync(i18nPath)) {
+      throw new Error("Could not find i18n config at ".concat(i18nPath, ", please provide a valid path."));
+    }
+  } else {
+    i18nPath = ['./i18n.tsx', './i18n.ts', './i18n.js', './i18n.jsx', './src/i18n.tsx', './src/i18n.ts', './src/i18n.js', './src/i18n.jsx'].map(cur => path__default.default.resolve(cwd, cur)).find(cur => fs__default.default.existsSync(cur));
+    if (!i18nPath) {
+      throw new Error("\n\nCould not locate i18n config. Create one at `./(src/)i18n.{js,jsx,ts,tsx}` or specify a custom location:\n\nconst withNextIntl = require('next-intl/plugin')(\n  './path/to/i18n.tsx'\n);\n\nmodule.exports = withNextIntl({\n  // Other Next.js configuration ...\n});\n");
+    }
+  }
+  return i18nPath;
+}
+function initPlugin(i18nPath, nextConfig) {
+  if ((nextConfig === null || nextConfig === void 0 ? void 0 : nextConfig.i18n) != null) {
+    console.warn("\nnext-intl has found an `i18n` config in your next.config.js. 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` folder, you can refer to this example: https://github.com/amannn/next-intl/tree/feat/next-13-rsc/packages/example-next-13-with-pages\n");
+  }
+  return Object.assign({}, nextConfig, {
+    webpack() {
+      for (var _len = arguments.length, _ref = new Array(_len), _key = 0; _key < _len; _key++) {
+        _ref[_key] = arguments[_key];
+      }
+      let [config, options] = _ref;
+      config.resolve.alias['next-intl/config'] = require.resolve(resolveI18nPath(config.context, i18nPath));
+      if (typeof (nextConfig === null || nextConfig === void 0 ? void 0 : nextConfig.webpack) === 'function') {
+        return nextConfig.webpack(config, options);
+      }
+      return config;
+    }
+  });
+}
+module.exports = function withNextIntl(i18nPath) {
+  return nextConfig => initPlugin(i18nPath, nextConfig);
+};

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

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useIntl = require('use-intl');
+
+/**
+ * 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.
+ */
+
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+function callHook(name, hook) {
+  return function () {
+    try {
+      return hook(...arguments);
+    } catch (e) {
+      throw new Error("Failed to call `".concat(name, "` because the context from `NextIntlClientProvider` was not found.\n\nThis can happen because:\n1) You intended to render this component as a Server Component, the render\n   failed, and therefore React attempted to render the component on the client\n   instead. If this is the case, check the console for server errors.\n2) You intended to render this component on the client side, but no context was found.\n   Learn more about this error here: https://next-intl-docs.vercel.app/docs/environments/server-client-components#missing-context") );
+    }
+  };
+}
+const useTranslations = callHook('useTranslations', useIntl.useTranslations);
+const useFormatter = callHook('useFormatter', useIntl.useFormatter);
+
+exports.useFormatter = useFormatter;
+exports.useTranslations = useTranslations;
+Object.keys(useIntl).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return useIntl[k]; }
+  });
+});

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

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var navigation = require('next/navigation');
+var _useLocale = require('use-intl/_useLocale');
+var constants = require('../shared/constants.js');
+
+function useLocale() {
+  let locale;
+
+  // The types aren't entirely correct here. Outside of Next.js
+  // `useParams` can be called, but the return type is `null`.
+  const params = navigation.useParams();
+  if (typeof (params === null || params === void 0 ? void 0 : params[constants.LOCALE_SEGMENT_NAME]) === 'string') {
+    locale = params[constants.LOCALE_SEGMENT_NAME];
+  } else {
+    // eslint-disable-next-line react-hooks/rules-of-hooks -- Reading from context conditionally is fine as long as we're in the render phase
+    locale = _useLocale.useLocale();
+  }
+  return locale;
+}
+
+exports.default = useLocale;