next-intl 2.22.0 → 2.22.2

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

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_virtual/_rollupPluginBabelHelpers.js');
+var React = require('react');
+var NextIntlClientProvider$1 = require('../shared/NextIntlClientProvider.js');
+var useLocale = require('./useLocale.js');
+var useNow = require('./useNow.js');
+var useTimeZone = require('./useTimeZone.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+function NextIntlClientProvider(_ref) {
+  let {
+    locale,
+    now,
+    timeZone,
+    ...rest
+  } = _ref;
+  const defaultLocale = useLocale.default();
+  const defaultNow = useNow.default();
+  const defaultTimeZone = useTimeZone.default();
+  return /*#__PURE__*/React__default.default.createElement(NextIntlClientProvider$1.default, _rollupPluginBabelHelpers.extends({
+    locale: locale !== null && locale !== void 0 ? locale : defaultLocale,
+    now: now !== null && now !== void 0 ? now : defaultNow,
+    timeZone: timeZone !== null && timeZone !== void 0 ? timeZone : defaultTimeZone
+  }, rest));
+}
+
+exports.default = NextIntlClientProvider;

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

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var core = require('use-intl/core');
+var getConfig = require('../server/getConfig.js');
+
+const getMessageFormatCache = React.cache(() => new Map());
+async function getTranslatorImpl(locale, namespace) {
+  const config = await getConfig.default(locale);
+  return core.createTranslator({
+    ...config,
+    messageFormatCache: getMessageFormatCache(),
+    namespace,
+    messages: config.messages
+  });
+}
+var getBaseTranslator = React.cache(getTranslatorImpl);
+
+exports.default = getBaseTranslator;

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

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var getFormatter = require('../server/getFormatter.js');
+var useHook = require('./useHook.js');
+var useLocale = require('./useLocale.js');
+
+function useFormatter() {
+  for (var _len = arguments.length, _ref = new Array(_len), _key = 0; _key < _len; _key++) {
+    _ref[_key] = arguments[_key];
+  }
+  const locale = useLocale.default();
+  return useHook.default('useFormatter', getFormatter.default({
+    locale
+  }));
+}
+
+exports.default = useFormatter;

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

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+function useHook(hookName, promise) {
+  try {
+    return React.use(promise);
+  } catch (error) {
+    if (error instanceof TypeError && error.message.includes("Cannot read properties of null (reading 'use')")) {
+      throw new Error("`".concat(hookName, "` is not callable within an async component. Please refer to https://next-intl-docs.vercel.app/docs/environments/server-client-components#async-components"), {
+        cause: error
+      });
+    } else {
+      throw error;
+    }
+  }
+}
+
+exports.default = useHook;

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

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var RequestLocale = require('../server/RequestLocale.js');
+
+function useLocale() {
+  for (var _len = arguments.length, _ref = new Array(_len), _key = 0; _key < _len; _key++) {
+    _ref[_key] = arguments[_key];
+  }
+  return RequestLocale.getRequestLocale();
+}
+
+exports.default = useLocale;

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

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var getMessages = require('../server/getMessages.js');
+var useHook = require('./useHook.js');
+var useLocale = require('./useLocale.js');
+
+function useMessages() {
+  for (var _len = arguments.length, _ref = new Array(_len), _key = 0; _key < _len; _key++) {
+    _ref[_key] = arguments[_key];
+  }
+  const locale = useLocale.default();
+  return useHook.default('useMessages', getMessages.default({
+    locale
+  }));
+}
+
+exports.default = useMessages;

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

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var getNow = require('../server/getNow.js');
+var useHook = require('./useHook.js');
+var useLocale = require('./useLocale.js');
+
+function useNow() {
+  for (var _len = arguments.length, _ref = new Array(_len), _key = 0; _key < _len; _key++) {
+    _ref[_key] = arguments[_key];
+  }
+  let [options] = _ref;
+  if ((options === null || options === void 0 ? void 0 : options.updateInterval) != null) {
+    console.error("`useNow` doesn't support the `updateInterval` option in Server Components, the value will be ignored. If you need the value to update, you can convert the component to a Client Component.");
+  }
+  const locale = useLocale.default();
+  return useHook.default('useNow', getNow.default({
+    locale
+  }));
+}
+
+exports.default = useNow;

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

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var getTimeZone = require('../server/getTimeZone.js');
+var useHook = require('./useHook.js');
+var useLocale = require('./useLocale.js');
+
+function useTimeZone() {
+  for (var _len = arguments.length, _ref = new Array(_len), _key = 0; _key < _len; _key++) {
+    _ref[_key] = arguments[_key];
+  }
+  const locale = useLocale.default();
+  return useHook.default('useTimeZone', getTimeZone.default({
+    locale
+  }));
+}
+
+exports.default = useTimeZone;

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

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var getBaseTranslator = require('./getBaseTranslator.js');
+var useHook = require('./useHook.js');
+var useLocale = require('./useLocale.js');
+
+function useTranslations() {
+  for (var _len = arguments.length, _ref = new Array(_len), _key = 0; _key < _len; _key++) {
+    _ref[_key] = arguments[_key];
+  }
+  let [namespace] = _ref;
+  const locale = useLocale.default();
+  const result = useHook.default('useTranslations', getBaseTranslator.default(locale, namespace));
+  return result;
+}
+
+exports.default = useTranslations;

package/dist/development/server/RequestLocale.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var headers = require('next/headers');
+var React = require('react');
+var constants = require('../shared/constants.js');
+
+const getLocaleFromHeader = React.cache(() => {
+  let locale;
+  try {
+    locale = headers.headers().get(constants.HEADER_LOCALE_NAME);
+  } catch (error) {
+    if (error instanceof Error && error.digest === 'DYNAMIC_SERVER_USAGE') {
+      throw new Error('Usage of next-intl APIs in Server Components currently opts into dynamic rendering. This limitation will eventually be lifted, but as a stopgap solution, you can use the `unstable_setRequestLocale` API to enable static rendering, see https://next-intl-docs.vercel.app/docs/getting-started/app-router-server-components#static-rendering', {
+        cause: error
+      });
+    } else {
+      throw error;
+    }
+  }
+  if (!locale) {
+    throw new Error("Unable to find `next-intl` locale because the middleware didn't run on this request. See https://next-intl-docs.vercel.app/docs/routing/middleware#unable-to-find-locale");
+  }
+  return locale;
+});
+
+// Workaround until `createServerContext` is available
+const getCache = React.cache(() => {
+  const value = {
+    locale: undefined
+  };
+  return value;
+});
+function setRequestLocale(locale) {
+  getCache().locale = locale;
+}
+function getRequestLocale() {
+  return getCache().locale || getLocaleFromHeader();
+}
+
+exports.getRequestLocale = getRequestLocale;
+exports.setRequestLocale = setRequestLocale;

package/dist/development/server/createRequestConfig.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var getRuntimeConfig = require('next-intl/config');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var getRuntimeConfig__default = /*#__PURE__*/_interopDefault(getRuntimeConfig);
+
+// @ts-expect-error
+// eslint-disable-next-line import/no-extraneous-dependencies
+
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () { return getRuntimeConfig__default.default; }
+});

package/dist/development/server/getConfig.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var core = require('use-intl/core');
+var getRuntimeConfig = require('next-intl/config');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var getRuntimeConfig__default = /*#__PURE__*/_interopDefault(getRuntimeConfig);
+
+// Make sure `now` is consistent across the request in case none was configured
+const getDefaultNow = React.cache(() => new Date());
+
+// This is automatically inherited by `NextIntlClientProvider` if
+// the component is rendered from a Server Component
+const getDefaultTimeZone = React.cache(() => Intl.DateTimeFormat().resolvedOptions().timeZone);
+const receiveRuntimeConfig = React.cache(async (locale, getConfig) => {
+  var _result, _result2;
+  let result = getConfig === null || getConfig === void 0 ? void 0 : getConfig({
+    locale
+  });
+  if (result instanceof Promise) {
+    result = await result;
+  }
+  return {
+    ...result,
+    now: ((_result = result) === null || _result === void 0 ? void 0 : _result.now) || getDefaultNow(),
+    timeZone: ((_result2 = result) === null || _result2 === void 0 ? void 0 : _result2.timeZone) || getDefaultTimeZone()
+  };
+});
+const getConfig = React.cache(async locale => {
+  const runtimeConfig = await receiveRuntimeConfig(locale, getRuntimeConfig__default.default);
+  const opts = {
+    ...runtimeConfig,
+    locale
+  };
+  return core.initializeConfig(opts);
+});
+var getConfig$1 = getConfig;
+
+exports.default = getConfig$1;

package/dist/development/server/getFormatter.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var core = require('use-intl/core');
+var getConfig = require('./getConfig.js');
+var resolveLocaleArg = require('./resolveLocaleArg.js');
+
+const getFormatterImpl = React.cache(async locale => {
+  const config = await getConfig.default(locale);
+  return core.createFormatter(config);
+});
+
+/**
+ * Returns a formatter based on the given locale.
+ *
+ * The formatter automatically receives the request config, but
+ * you can override it by passing in additional options.
+ */
+async function getFormatter(opts) {
+  const locale = await resolveLocaleArg.default(opts);
+  return getFormatterImpl(locale);
+}
+
+exports.default = getFormatter;

package/dist/development/server/getLocale.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var RequestLocale = require('./RequestLocale.js');
+
+function getLocale() {
+  return Promise.resolve(RequestLocale.getRequestLocale());
+}
+
+exports.default = getLocale;

package/dist/development/server/getMessages.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var getConfig = require('./getConfig.js');
+var resolveLocaleArg = require('./resolveLocaleArg.js');
+
+const getMessagesImpl = React.cache(async locale => {
+  const config = await getConfig.default(locale);
+  if (!config.messages) {
+    throw new Error('No messages found. Have you configured them correctly? See https://next-intl-docs.vercel.app/docs/configuration#messages');
+  }
+  return config.messages;
+});
+async function getMessages(opts) {
+  const locale = await resolveLocaleArg.default(opts);
+  return getMessagesImpl(locale);
+}
+
+exports.default = getMessages;

package/dist/development/server/getNow.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var getConfig = require('./getConfig.js');
+var resolveLocaleArg = require('./resolveLocaleArg.js');
+
+const getNowImpl = React.cache(async locale => {
+  const config = await getConfig.default(locale);
+  return config.now;
+});
+async function getNow(opts) {
+  const locale = await resolveLocaleArg.default(opts);
+  return getNowImpl(locale);
+}
+
+exports.default = getNow;

package/dist/development/server/getRequestConfig.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Should be called in `i18n.ts` to create the configuration for the current request.
+ */
+function getRequestConfig(createRequestConfig) {
+  return createRequestConfig;
+}
+
+exports.default = getRequestConfig;

package/dist/development/server/getTimeZone.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var getConfig = require('./getConfig.js');
+var resolveLocaleArg = require('./resolveLocaleArg.js');
+
+const getTimeZoneImpl = React.cache(async locale => {
+  const config = await getConfig.default(locale);
+  return config.timeZone;
+});
+async function getTimeZone(opts) {
+  const locale = await resolveLocaleArg.default(opts);
+  return getTimeZoneImpl(locale);
+}
+
+exports.default = getTimeZone;

package/dist/development/server/getTranslations.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var core = require('use-intl/core');
+var getConfig = require('./getConfig.js');
+var getLocale = require('./getLocale.js');
+
+// Maintainer note: `getTranslations` has two different call signatures.
+// We need to define these with function overloads, otherwise TypeScript
+// messes up the return type.
+async function getTranslations(namespaceOrOpts) {
+  let namespace;
+  let locale;
+  if (typeof namespaceOrOpts === 'string') {
+    namespace = namespaceOrOpts;
+  } else if (namespaceOrOpts) {
+    locale = namespaceOrOpts.locale;
+    namespace = namespaceOrOpts.namespace;
+  }
+  const config = await getConfig.default(locale || (await getLocale.default()));
+  return core.createTranslator({
+    ...config,
+    namespace,
+    messages: config.messages
+  });
+}
+var getTranslations$1 = React.cache(getTranslations);
+
+exports.default = getTranslations$1;

package/dist/development/server/resolveLocaleArg.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var getLocale = require('./getLocale.js');
+
+function resolveLocaleArg(opts) {
+  if (opts !== null && opts !== void 0 && opts.locale) {
+    return Promise.resolve(opts.locale);
+  } else {
+    return getLocale.default();
+  }
+}
+
+exports.default = resolveLocaleArg;

package/dist/development/server.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var getRequestConfig = require('./server/getRequestConfig.js');
+var getFormatter = require('./server/getFormatter.js');
+var getNow = require('./server/getNow.js');
+var getTimeZone = require('./server/getTimeZone.js');
+var getTranslations = require('./server/getTranslations.js');
+var getMessages = require('./server/getMessages.js');
+var getLocale = require('./server/getLocale.js');
+var RequestLocale = require('./server/RequestLocale.js');
+
+
+
+exports.getRequestConfig = getRequestConfig.default;
+exports.getFormatter = getFormatter.default;
+exports.getNow = getNow.default;
+exports.getTimeZone = getTimeZone.default;
+exports.getTranslations = getTranslations.default;
+exports.getMessages = getMessages.default;
+exports.getLocale = getLocale.default;
+exports.unstable_setRequestLocale = RequestLocale.setRequestLocale;

package/dist/development/shared/BaseLinkWithLocale.js

@@ -0,0 +1,58 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_virtual/_rollupPluginBabelHelpers.js');
+var NextLink = require('next/link');
+var navigation = require('next/navigation');
+var React = require('react');
+var useLocale = require('../react-client/useLocale.js');
+var utils = require('./utils.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var NextLink__default = /*#__PURE__*/_interopDefault(NextLink);
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+function BaseLinkWithLocale(_ref, ref) {
+  let {
+    href,
+    locale,
+    prefetch,
+    ...rest
+  } = _ref;
+  // The types aren't entirely correct here. Outside of Next.js
+  // `useParams` can be called, but the return type is `null`.
+  const pathname = navigation.usePathname();
+  const defaultLocale = useLocale.default();
+  const isChangingLocale = locale !== defaultLocale;
+  const [localizedHref, setLocalizedHref] = React.useState(() => utils.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.
+  utils.prefixHref(href, locale) : href);
+  React.useEffect(() => {
+    if (!pathname) return;
+    setLocalizedHref(utils.localizeHref(href, locale, defaultLocale, pathname !== null && pathname !== void 0 ? pathname : undefined));
+  }, [defaultLocale, href, locale, pathname]);
+  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;
+  }
+  return /*#__PURE__*/React__default.default.createElement(NextLink__default.default, _rollupPluginBabelHelpers.extends({
+    ref: ref,
+    href: localizedHref,
+    prefetch: prefetch
+  }, rest));
+}
+var BaseLinkWithLocale$1 = /*#__PURE__*/React.forwardRef(BaseLinkWithLocale);
+
+exports.default = BaseLinkWithLocale$1;

package/dist/development/shared/NextIntlClientProvider.js

@@ -0,0 +1,30 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_virtual/_rollupPluginBabelHelpers.js');
+var React = require('react');
+var _IntlProvider = require('use-intl/_IntlProvider');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+function NextIntlClientProvider(_ref) {
+  let {
+    locale,
+    ...rest
+  } = _ref;
+  // TODO: We could call `useParams` here to receive a default value
+  // for `locale`, but this would require dropping Next.js <13.
+
+  if (!locale) {
+    throw new Error('Failed to determine locale in `NextIntlClientProvider`, please provide the `locale` prop explicitly.\n\nSee https://next-intl-docs.vercel.app/docs/configuration#locale' );
+  }
+  return /*#__PURE__*/React__default.default.createElement(_IntlProvider.IntlProvider, _rollupPluginBabelHelpers.extends({
+    locale: locale
+  }, rest));
+}
+
+exports.default = NextIntlClientProvider;

package/dist/development/shared/constants.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// Reuse the legacy cookie name
+// https://nextjs.org/docs/advanced-features/i18n-routing#leveraging-the-next_locale-cookie
+const COOKIE_LOCALE_NAME = 'NEXT_LOCALE';
+
+// Should take precedence over the cookie
+const HEADER_LOCALE_NAME = 'X-NEXT-INTL-LOCALE';
+
+// In a URL like "/en-US/about", the locale segment is "en-US"
+const LOCALE_SEGMENT_NAME = 'locale';
+
+exports.COOKIE_LOCALE_NAME = COOKIE_LOCALE_NAME;
+exports.HEADER_LOCALE_NAME = HEADER_LOCALE_NAME;
+exports.LOCALE_SEGMENT_NAME = LOCALE_SEGMENT_NAME;

package/dist/development/shared/redirectWithLocale.js

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