@depup/next-intl 4.8.3-depup.0

package/dist/esm/development/server/react-server/RequestLocale.js

@@ -0,0 +1,36 @@
+import { headers } from 'next/headers';
+import { cache } from 'react';
+import { HEADER_LOCALE_NAME } from '../../shared/constants.js';
+import { isPromise } from '../../shared/utils.js';
+import { getCachedRequestLocale } from './RequestLocaleCache.js';
+
+async function getHeadersImpl() {
+  const promiseOrValue = headers();
+
+  // Compatibility with Next.js <15
+  return isPromise(promiseOrValue) ? await promiseOrValue : promiseOrValue;
+}
+const getHeaders = cache(getHeadersImpl);
+async function getLocaleFromHeaderImpl() {
+  let locale;
+  try {
+    locale = (await getHeaders()).get(HEADER_LOCALE_NAME) || undefined;
+  } catch (error) {
+    if (error instanceof Error && error.digest === 'DYNAMIC_SERVER_USAGE') {
+      const wrappedError = 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 `setRequestLocale` API to enable static rendering, see https://next-intl.dev/docs/routing/setup#static-rendering', {
+        cause: error
+      });
+      wrappedError.digest = error.digest;
+      throw wrappedError;
+    } else {
+      throw error;
+    }
+  }
+  return locale;
+}
+const getLocaleFromHeader = cache(getLocaleFromHeaderImpl);
+async function getRequestLocale() {
+  return getCachedRequestLocale() || (await getLocaleFromHeader());
+}
+
+export { getRequestLocale };

package/dist/esm/development/server/react-server/RequestLocaleCache.js

@@ -0,0 +1,18 @@
+import { cache } from 'react';
+
+// See https://github.com/vercel/next.js/discussions/58862
+function getCacheImpl() {
+  const value = {
+    locale: undefined
+  };
+  return value;
+}
+const getCache = cache(getCacheImpl);
+function getCachedRequestLocale() {
+  return getCache().locale;
+}
+function setCachedRequestLocale(locale) {
+  getCache().locale = locale;
+}
+
+export { getCachedRequestLocale, setCachedRequestLocale };

package/dist/esm/development/server/react-server/createRequestConfig.js

@@ -0,0 +1,2 @@
+import getRuntimeConfig from 'next-intl/config';
+export { default } from 'next-intl/config';

package/dist/esm/development/server/react-server/getConfig.js

@@ -0,0 +1,59 @@
+import { cache } from 'react';
+import { initializeConfig, _createIntlFormatters, _createCache } from 'use-intl/core';
+import { isPromise } from '../../shared/utils.js';
+import { getRequestLocale } from './RequestLocale.js';
+import getRuntimeConfig from 'next-intl/config';
+import validateLocale from './validateLocale.js';
+
+// This is automatically inherited by `NextIntlClientProvider` if
+// the component is rendered from a Server Component
+function getDefaultTimeZoneImpl() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+const getDefaultTimeZone = cache(getDefaultTimeZoneImpl);
+async function receiveRuntimeConfigImpl(getConfig, localeOverride) {
+  if (typeof getConfig !== 'function') {
+    throw new Error(`Invalid i18n request configuration detected.
+
+Please verify that:
+1. In case you've specified a custom location in your Next.js config, make sure that the path is correct.
+2. You have a default export in your i18n request configuration file.
+
+See also: https://next-intl.dev/docs/usage/configuration#i18n-request
+`);
+  }
+  const params = {
+    locale: localeOverride,
+    // In case the consumer doesn't read `params.locale` and instead provides the
+    // `locale` (either in a single-language workflow or because the locale is
+    // read from the user settings), don't attempt to read the request locale.
+    get requestLocale() {
+      return localeOverride ? Promise.resolve(localeOverride) : getRequestLocale();
+    }
+  };
+  let result = getConfig(params);
+  if (isPromise(result)) {
+    result = await result;
+  }
+  if (!result.locale) {
+    throw new Error('No locale was returned from `getRequestConfig`.\n\nSee https://next-intl.dev/docs/usage/configuration#i18n-request');
+  }
+  {
+    validateLocale(result.locale);
+  }
+  return result;
+}
+const receiveRuntimeConfig = cache(receiveRuntimeConfigImpl);
+const getFormatters = cache(_createIntlFormatters);
+const getCache = cache(_createCache);
+async function getConfigImpl(localeOverride) {
+  const runtimeConfig = await receiveRuntimeConfig(getRuntimeConfig, localeOverride);
+  return {
+    ...initializeConfig(runtimeConfig),
+    _formatters: getFormatters(getCache()),
+    timeZone: runtimeConfig.timeZone || getDefaultTimeZone()
+  };
+}
+const getConfig = cache(getConfigImpl);
+
+export { getConfig as default };

package/dist/esm/development/server/react-server/getConfigNow.js

@@ -0,0 +1,10 @@
+import { cache } from 'react';
+import getConfig from './getConfig.js';
+
+async function getConfigNowImpl(locale) {
+  const config = await getConfig(locale);
+  return config.now;
+}
+const getConfigNow = cache(getConfigNowImpl);
+
+export { getConfigNow as default };

package/dist/esm/development/server/react-server/getDefaultNow.js

@@ -0,0 +1,9 @@
+import { cache } from 'react';
+
+function defaultNow() {
+  // See https://next-intl.dev/docs/usage/dates-times#relative-times-server
+  return new Date();
+}
+const getDefaultNow = cache(defaultNow);
+
+export { getDefaultNow as default };

package/dist/esm/development/server/react-server/getExtracted.js

@@ -0,0 +1,24 @@
+import { cache } from 'react';
+import getConfig from './getConfig.js';
+import getServerExtractor from './getServerExtractor.js';
+
+// Call signature 1: `getExtracted(namespace)`
+
+// Call signature 2: `getExtracted({locale, namespace})`
+
+// Implementation
+async function getExtractedImpl(namespaceOrOpts) {
+  let namespace;
+  let locale;
+  if (typeof namespaceOrOpts === 'string') {
+    namespace = namespaceOrOpts;
+  } else if (namespaceOrOpts) {
+    locale = namespaceOrOpts.locale;
+    namespace = namespaceOrOpts.namespace;
+  }
+  const config = await getConfig(locale);
+  return getServerExtractor(config, namespace);
+}
+const getExtracted = cache(getExtractedImpl);
+
+export { getExtracted as default };

package/dist/esm/development/server/react-server/getFormats.js

@@ -0,0 +1,10 @@
+import { cache } from 'react';
+import getConfig from './getConfig.js';
+
+async function getFormatsCachedImpl() {
+  const config = await getConfig();
+  return config.formats;
+}
+const getFormats = cache(getFormatsCachedImpl);
+
+export { getFormats as default };

package/dist/esm/development/server/react-server/getFormatter.js

@@ -0,0 +1,21 @@
+import { cache } from 'react';
+import getConfig from './getConfig.js';
+import getFormatterCached$1 from './getServerFormatter.js';
+
+async function getFormatterCachedImpl(locale) {
+  const config = await getConfig(locale);
+  return getFormatterCached$1(config);
+}
+const getFormatterCached = cache(getFormatterCachedImpl);
+
+/**
+ * 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) {
+  return getFormatterCached(opts?.locale);
+}
+
+export { getFormatter as default };

package/dist/esm/development/server/react-server/getLocale.js

@@ -0,0 +1,10 @@
+import { cache } from 'react';
+import getConfig from './getConfig.js';
+
+async function getLocaleCachedImpl() {
+  const config = await getConfig();
+  return config.locale;
+}
+const getLocaleCached = cache(getLocaleCachedImpl);
+
+export { getLocaleCached as default };

package/dist/esm/development/server/react-server/getMessages.js

@@ -0,0 +1,19 @@
+import { cache } from 'react';
+import getConfig from './getConfig.js';
+
+function getMessagesFromConfig(config) {
+  if (!config.messages) {
+    throw new Error('No messages found. Have you configured them correctly? See https://next-intl.dev/docs/configuration#messages');
+  }
+  return config.messages;
+}
+async function getMessagesCachedImpl(locale) {
+  const config = await getConfig(locale);
+  return getMessagesFromConfig(config);
+}
+const getMessagesCached = cache(getMessagesCachedImpl);
+async function getMessages(opts) {
+  return getMessagesCached(opts?.locale);
+}
+
+export { getMessages as default, getMessagesFromConfig };

package/dist/esm/development/server/react-server/getNow.js

@@ -0,0 +1,8 @@
+import getConfigNow from './getConfigNow.js';
+import getDefaultNow from './getDefaultNow.js';
+
+async function getNow(opts) {
+  return (await getConfigNow(opts?.locale)) ?? getDefaultNow();
+}
+
+export { getNow as default };

package/dist/esm/development/server/react-server/getRequestConfig.js

@@ -0,0 +1,8 @@
+/**
+ * Should be called in `i18n/request.ts` to create the configuration for the current request.
+ */
+function getRequestConfig(createRequestConfig) {
+  return createRequestConfig;
+}
+
+export { getRequestConfig as default };

package/dist/esm/development/server/react-server/getServerExtractor.js

@@ -0,0 +1,38 @@
+import { cache } from 'react';
+import getServerTranslator from './getServerTranslator.js';
+
+// Note: This API is usually compiled into `useTranslations`,
+// but there is some fallback handling which allows this hook
+// to still work when not being compiled.
+//
+// This is relevant for:
+// - Isolated environments like tests, Storybook, etc.
+// - Fallbacks in case an extracted message is not yet available
+function getServerExtractorImpl(config, namespace) {
+  const t = getServerTranslator(config, namespace);
+  function translateFn(...[message, values, formats]) {
+    return t(undefined, values, formats,
+    // @ts-expect-error -- Secret fallback parameter
+    message );
+  }
+  translateFn.rich = function translateRichFn(...[message, values, formats]) {
+    return t.rich(undefined, values, formats,
+    // @ts-expect-error -- Secret fallback parameter
+    message );
+  };
+  translateFn.markup = function translateMarkupFn(...[message, values, formats]) {
+    return t.markup(undefined, values, formats,
+    // @ts-expect-error -- Secret fallback parameter
+    message );
+  };
+  translateFn.has = function translateHasFn(
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  ...[message]) {
+    // Not really something better we can do here
+    return true;
+  };
+  return translateFn;
+}
+var getServerExtractor = cache(getServerExtractorImpl);
+
+export { getServerExtractor as default };

package/dist/esm/development/server/react-server/getServerFormatter.js

@@ -0,0 +1,17 @@
+import { cache } from 'react';
+import { createFormatter } from 'use-intl/core';
+import getDefaultNow from './getDefaultNow.js';
+
+function getFormatterCachedImpl(config) {
+  return createFormatter({
+    ...config,
+    // Only init when necessary to avoid triggering a `dynamicIO` error
+    // unnecessarily (`now` is only needed for `format.relativeTime`)
+    get now() {
+      return config.now ?? getDefaultNow();
+    }
+  });
+}
+const getFormatterCached = cache(getFormatterCachedImpl);
+
+export { getFormatterCached as default };

package/dist/esm/development/server/react-server/getServerTranslator.js

@@ -0,0 +1,12 @@
+import { cache } from 'react';
+import { createTranslator } from 'use-intl/core';
+
+function getServerTranslatorImpl(config, namespace) {
+  return createTranslator({
+    ...config,
+    namespace
+  });
+}
+var getServerTranslator = cache(getServerTranslatorImpl);
+
+export { getServerTranslator as default };

package/dist/esm/development/server/react-server/getTimeZone.js

@@ -0,0 +1,13 @@
+import { cache } from 'react';
+import getConfig from './getConfig.js';
+
+async function getTimeZoneCachedImpl(locale) {
+  const config = await getConfig(locale);
+  return config.timeZone;
+}
+const getTimeZoneCached = cache(getTimeZoneCachedImpl);
+async function getTimeZone(opts) {
+  return getTimeZoneCached(opts?.locale);
+}
+
+export { getTimeZone as default };

package/dist/esm/development/server/react-server/getTranslations.js

@@ -0,0 +1,28 @@
+import { cache } from 'react';
+import getConfig from './getConfig.js';
+import getServerTranslator from './getServerTranslator.js';
+
+// Maintainer note: `getTranslations` has two different call signatures.
+// We need to define these with function overloads, otherwise TypeScript
+// messes up the return type.
+
+// Call signature 1: `getTranslations(namespace)`
+
+// Call signature 2: `getTranslations({locale, namespace})`
+
+// Implementation
+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(locale);
+  return getServerTranslator(config, namespace);
+}
+var getTranslations_default = cache(getTranslations);
+
+export { getTranslations_default as default };

package/dist/esm/development/server/react-server/validateLocale.js

@@ -0,0 +1,12 @@
+function validateLocale(locale) {
+  try {
+    const constructed = new Intl.Locale(locale);
+    if (!constructed.language) {
+      throw new Error('Language is required');
+    }
+  } catch {
+    console.error(`An invalid locale was provided: "${locale}"\nPlease ensure you're using a valid Unicode locale identifier (e.g. "en-US").`);
+  }
+}
+
+export { validateLocale as default };

package/dist/esm/development/server.react-client.js

@@ -0,0 +1 @@
+export { getExtracted, getFormatter, getLocale, getMessages, getNow, getRequestConfig, getTimeZone, getTranslations, setRequestLocale } from './server/react-client/index.js';

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

@@ -0,0 +1,9 @@
+export { default as getRequestConfig } from './server/react-server/getRequestConfig.js';
+export { default as getFormatter } from './server/react-server/getFormatter.js';
+export { default as getNow } from './server/react-server/getNow.js';
+export { default as getTimeZone } from './server/react-server/getTimeZone.js';
+export { default as getExtracted } from './server/react-server/getExtracted.js';
+export { default as getMessages } from './server/react-server/getMessages.js';
+export { default as getLocale } from './server/react-server/getLocale.js';
+export { default as getTranslations } from './server/react-server/getTranslations.js';
+export { setCachedRequestLocale as setRequestLocale } from './server/react-server/RequestLocaleCache.js';

package/dist/esm/development/shared/NextIntlClientProvider.js

@@ -0,0 +1,18 @@
+"use client";
+import { IntlProvider } from 'use-intl/react';
+import { jsx } from 'react/jsx-runtime';
+
+function NextIntlClientProvider({
+  locale,
+  ...rest
+}) {
+  if (!locale) {
+    throw new Error("Couldn't infer the `locale` prop in `NextIntlClientProvider`, please provide it explicitly.\n\nSee https://next-intl.dev/docs/configuration#locale" );
+  }
+  return /*#__PURE__*/jsx(IntlProvider, {
+    locale: locale,
+    ...rest
+  });
+}
+
+export { NextIntlClientProvider as default };

package/dist/esm/development/shared/constants.js

@@ -0,0 +1,4 @@
+// Used to read the locale from the middleware
+const HEADER_LOCALE_NAME = 'X-NEXT-INTL-LOCALE';
+
+export { HEADER_LOCALE_NAME };

package/dist/esm/development/shared/use.js

@@ -0,0 +1,13 @@
+import * as react from 'react';
+
+// @ts-expect-error -- Ooof, Next.js doesn't make this easy.
+// `use` is only available in React 19 canary, but we can
+// use it in Next.js already as Next.js "vendors" a fixed
+// version of React. However, if we'd simply put `use` in
+// ESM code, then the build doesn't work since React does
+// not export `use` officially. Therefore, we have to use
+// something that is not statically analyzable. Once React
+// 19 is out, we can remove this in the next major version.
+var use = react['use'.trim()];
+
+export { use as default };

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

@@ -0,0 +1,140 @@
+function isRelativeHref(href) {
+  const pathname = typeof href === 'object' ? href.pathname : href;
+  return pathname != null && !pathname.startsWith('/');
+}
+function isLocalHref(href) {
+  if (typeof href === 'object') {
+    return href.host == null && href.hostname == null;
+  } else {
+    const hasProtocol = /^[a-z]+:/i.test(href);
+    return !hasProtocol;
+  }
+}
+function isLocalizableHref(href) {
+  return isLocalHref(href) && !isRelativeHref(href);
+}
+function unprefixPathname(pathname, prefix) {
+  return pathname.replace(new RegExp(`^${prefix}`), '') || '/';
+}
+function prefixPathname(prefix, pathname) {
+  let localizedHref = prefix;
+
+  // Avoid trailing slashes
+  if (/^\/(\?.*)?$/.test(pathname)) {
+    pathname = pathname.slice(1);
+  }
+  localizedHref += pathname;
+  return localizedHref;
+}
+function hasPathnamePrefixed(prefix, pathname) {
+  return pathname === prefix || pathname.startsWith(`${prefix}/`);
+}
+function hasTrailingSlash() {
+  try {
+    // Provided via `env` setting in `next.config.js` via the plugin
+    return process.env._next_intl_trailing_slash === 'true';
+  } catch {
+    return false;
+  }
+}
+function getLocalizedTemplate(pathnameConfig, locale, internalTemplate) {
+  return typeof pathnameConfig === 'string' ? pathnameConfig : pathnameConfig[locale] || internalTemplate;
+}
+function normalizeTrailingSlash(pathname) {
+  const trailingSlash = hasTrailingSlash();
+  const [path, ...hashParts] = pathname.split('#');
+  const hash = hashParts.join('#');
+  let normalizedPath = path;
+  if (normalizedPath !== '/') {
+    const pathnameEndsWithSlash = normalizedPath.endsWith('/');
+    if (trailingSlash && !pathnameEndsWithSlash) {
+      normalizedPath += '/';
+    } else if (!trailingSlash && pathnameEndsWithSlash) {
+      normalizedPath = normalizedPath.slice(0, -1);
+    }
+  }
+  if (hash) {
+    normalizedPath += '#' + hash;
+  }
+  return normalizedPath;
+}
+function matchesPathname(/** E.g. `/users/[userId]-[userName]` */
+template, /** E.g. `/users/23-jane` */
+pathname) {
+  const normalizedTemplate = normalizeTrailingSlash(template);
+  const normalizedPathname = normalizeTrailingSlash(pathname);
+  const regex = templateToRegex(normalizedTemplate);
+  return regex.test(normalizedPathname);
+}
+function getLocalePrefix(locale, localePrefix) {
+  return localePrefix.mode !== 'never' && localePrefix.prefixes?.[locale] ||
+  // We return a prefix even if `mode: 'never'`. It's up to the consumer
+  // to decide to use it or not.
+  getLocaleAsPrefix(locale);
+}
+function getLocaleAsPrefix(locale) {
+  return '/' + locale;
+}
+function templateToRegex(template) {
+  const regexPattern = template
+  // Replace optional catchall ('[[...slug]]')
+  .replace(/\/\[\[(\.\.\.[^\]]+)\]\]/g, '(?:/(.*))?') // With leading slash
+  .replace(/\[\[(\.\.\.[^\]]+)\]\]/g, '(?:/(.*))?') // Without leading slash
+  // Replace catchall ('[...slug]')
+  .replace(/\[(\.\.\.[^\]]+)\]/g, '(.+)')
+  // Replace regular parameter ('[slug]')
+  .replace(/\[([^\]]+)\]/g, '([^/]+)');
+  return new RegExp(`^${regexPattern}$`);
+}
+function isOptionalCatchAllSegment(pathname) {
+  return pathname.includes('[[...');
+}
+function isCatchAllSegment(pathname) {
+  return pathname.includes('[...');
+}
+function isDynamicSegment(pathname) {
+  return pathname.includes('[');
+}
+function comparePathnamePairs(a, b) {
+  const pathA = a.split('/');
+  const pathB = b.split('/');
+  const maxLength = Math.max(pathA.length, pathB.length);
+  for (let i = 0; i < maxLength; i++) {
+    const segmentA = pathA[i];
+    const segmentB = pathB[i];
+
+    // If one of the paths ends, prioritize the shorter path
+    if (!segmentA && segmentB) return -1;
+    if (segmentA && !segmentB) return 1;
+    if (!segmentA && !segmentB) continue;
+
+    // Prioritize static segments over dynamic segments
+    if (!isDynamicSegment(segmentA) && isDynamicSegment(segmentB)) return -1;
+    if (isDynamicSegment(segmentA) && !isDynamicSegment(segmentB)) return 1;
+
+    // Prioritize non-catch-all segments over catch-all segments
+    if (!isCatchAllSegment(segmentA) && isCatchAllSegment(segmentB)) return -1;
+    if (isCatchAllSegment(segmentA) && !isCatchAllSegment(segmentB)) return 1;
+
+    // Prioritize non-optional catch-all segments over optional catch-all segments
+    if (!isOptionalCatchAllSegment(segmentA) && isOptionalCatchAllSegment(segmentB)) {
+      return -1;
+    }
+    if (isOptionalCatchAllSegment(segmentA) && !isOptionalCatchAllSegment(segmentB)) {
+      return 1;
+    }
+    if (segmentA === segmentB) continue;
+  }
+
+  // Both pathnames are completely static
+  return 0;
+}
+function getSortedPathnames(pathnames) {
+  return pathnames.sort(comparePathnamePairs);
+}
+function isPromise(value) {
+  // https://github.com/amannn/next-intl/issues/1711
+  return typeof value.then === 'function';
+}
+
+export { getLocaleAsPrefix, getLocalePrefix, getLocalizedTemplate, getSortedPathnames, hasPathnamePrefixed, isLocalizableHref, isPromise, matchesPathname, normalizeTrailingSlash, prefixPathname, templateToRegex, unprefixPathname };

package/dist/esm/production/config.js

@@ -0,0 +1 @@
+function t(){throw new Error("Couldn't find next-intl config file. Please follow the instructions at https://next-intl.dev/docs/getting-started/app-router")}export{t as default};

package/dist/esm/production/extractor/ExtractionCompiler.js

@@ -0,0 +1 @@
+import s from"./catalog/CatalogManager.js";import t from"./extractor/MessageExtractor.js";class o{constructor(o,a={}){const e=a.extractor??new t(a);this.manager=new s(o,{...a,extractor:e}),this[Symbol.dispose]=this[Symbol.dispose].bind(this),this.installExitHandlers()}async extractAll(){await this.manager.loadMessages(),await this.manager.save()}[Symbol.dispose](){this.uninstallExitHandlers(),this.manager[Symbol.dispose]()}installExitHandlers(){const s=this[Symbol.dispose];process.on("exit",s),process.on("SIGINT",s),process.on("SIGTERM",s)}uninstallExitHandlers(){const s=this[Symbol.dispose];process.off("exit",s),process.off("SIGINT",s),process.off("SIGTERM",s)}}export{o as default};

package/dist/esm/production/extractor/catalog/CatalogLocales.js

@@ -0,0 +1 @@
+import e from"fs";import s from"fs/promises";import t from"path";class a{onChangeCallbacks=new Set;constructor(e){this.messagesDir=e.messagesDir,this.sourceLocale=e.sourceLocale,this.extension=e.extension,this.locales=e.locales}async getTargetLocales(){return this.targetLocales||("infer"===this.locales?this.targetLocales=await this.readTargetLocales():this.targetLocales=this.locales.filter((e=>e!==this.sourceLocale))),this.targetLocales}async readTargetLocales(){try{return(await s.readdir(this.messagesDir)).filter((e=>e.endsWith(this.extension))).map((e=>t.basename(e,this.extension))).filter((e=>e!==this.sourceLocale))}catch{return[]}}subscribeLocalesChange(e){this.onChangeCallbacks.add(e),"infer"!==this.locales||this.watcher||this.startWatcher()}unsubscribeLocalesChange(e){this.onChangeCallbacks.delete(e),0===this.onChangeCallbacks.size&&this.stopWatcher()}async startWatcher(){this.watcher||(await s.mkdir(this.messagesDir,{recursive:!0}),this.watcher=e.watch(this.messagesDir,{persistent:!1,recursive:!1},((e,s)=>{null!=s&&s.endsWith(this.extension)&&!s.includes(t.sep)&&this.onChange()})))}stopWatcher(){this.watcher&&(this.watcher.close(),this.watcher=void 0)}async onChange(){const e=new Set(this.targetLocales||[]);this.targetLocales=await this.readTargetLocales();const s=new Set(this.targetLocales),t=this.targetLocales.filter((s=>!e.has(s))),a=Array.from(e).filter((e=>!s.has(e)));if(t.length>0||a.length>0)for(const e of this.onChangeCallbacks)e({added:t,removed:a})}}export{a as default};

package/dist/esm/production/extractor/catalog/CatalogManager.js

@@ -0,0 +1 @@
+import e from"fs/promises";import s from"path";import{resolveCodec as t,getFormatExtension as a}from"../format/index.js";import o from"../source/SourceFileScanner.js";import i from"../source/SourceFileWatcher.js";import{getDefaultProjectRoot as r,normalizePathToPosix as c,compareReferences as l}from"../utils.js";import n from"./CatalogLocales.js";import h from"./CatalogPersister.js";import g from"./SaveScheduler.js";class m{messagesByFile=new Map;messagesById=new Map;translationsByTargetLocale=new Map;lastWriteByLocale=new Map;constructor(e,s){this.config=e,this.saveScheduler=new g(50),this.projectRoot=s.projectRoot??r(),this.isDevelopment=s.isDevelopment??!1,this.extractor=s.extractor,this.isDevelopment&&(this.sourceWatcher=new i(this.getSrcPaths(),this.handleFileEvents.bind(this)),this.sourceWatcher.start())}async getCodec(){return this.codec||(this.codec=await t(this.config.messages.format,this.projectRoot)),this.codec}async getPersister(){return this.persister||(this.persister=new h({messagesPath:this.config.messages.path,codec:await this.getCodec(),extension:a(this.config.messages.format)})),this.persister}getCatalogLocales(){if(this.catalogLocales)return this.catalogLocales;{const e=s.join(this.projectRoot,this.config.messages.path);return this.catalogLocales=new n({messagesDir:e,sourceLocale:this.config.sourceLocale,extension:a(this.config.messages.format),locales:this.config.messages.locales}),this.catalogLocales}}async getTargetLocales(){return this.getCatalogLocales().getTargetLocales()}getSrcPaths(){return(Array.isArray(this.config.srcPath)?this.config.srcPath:[this.config.srcPath]).map((e=>s.join(this.projectRoot,e)))}async loadMessages(){const e=await this.loadSourceMessages();if(this.loadCatalogsPromise=this.loadTargetMessages(),await this.loadCatalogsPromise,this.scanCompletePromise=(async()=>{const s=await o.getSourceFiles(this.getSrcPaths());await Promise.all(Array.from(s).map((async e=>this.processFile(e)))),this.mergeSourceDiskMetadata(e)})(),await this.scanCompletePromise,this.isDevelopment){this.getCatalogLocales().subscribeLocalesChange(this.onLocalesChange)}}async loadSourceMessages(){const e=await this.loadLocaleMessages(this.config.sourceLocale),s=new Map;for(const t of e)s.set(t.id,t);return s}async loadLocaleMessages(e){const s=await this.getPersister(),t=await s.read(e),a=await s.getLastModified(e);return this.lastWriteByLocale.set(e,a),t}async loadTargetMessages(){const e=await this.getTargetLocales();await Promise.all(e.map((e=>this.reloadLocaleCatalog(e))))}async reloadLocaleCatalog(e){const s=await this.loadLocaleMessages(e);if(e===this.config.sourceLocale)for(const e of s){const s=this.messagesById.get(e.id);if(s)for(const t of Object.keys(e))["id","message","description","references"].includes(t)||(s[t]=e[t])}else{const t=this.translationsByTargetLocale.get(e),a=t&&t.size>0;if(s.length>0){const t=new Map;for(const e of s)t.set(e.id,e);this.translationsByTargetLocale.set(e,t)}else if(a);else{const s=new Map;this.translationsByTargetLocale.set(e,s)}}}mergeSourceDiskMetadata(e){for(const[s,t]of e){const e=this.messagesById.get(s);if(e)for(const s of Object.keys(t))null==e[s]&&(e[s]=t[s])}}async processFile(t){let a=[];try{const s=await e.readFile(t,"utf8");let o;try{o=await this.extractor.extract(t,s)}catch{return!1}a=o.messages}catch(e){if("ENOENT"!==e.code)throw e}const o=this.messagesByFile.get(t),i=c(s.relative(this.projectRoot,t)),r=Array.from(o?.keys()??[]),l=new Map;for(let e of a){const s=this.messagesById.get(e.id);if(s){e={...e},e.references&&(e.references=this.mergeReferences(s.references??[],i,e.references));for(const t of Object.keys(s))null==e[t]&&(e[t]=s[t])}this.messagesById.set(e.id,e),l.set(e.id,e);const t=r.indexOf(e.id);-1!==t&&r.splice(t,1)}r.forEach((e=>{const s=this.messagesById.get(e);if(!s)return;const t=s.references?.some((e=>e.path!==i));t?s.references=s.references?.filter((e=>e.path!==i)):this.messagesById.delete(e)})),a.length>0?this.messagesByFile.set(t,l):this.messagesByFile.delete(t);return this.haveMessagesChangedForFile(o,l)}mergeReferences(e,s,t){return[...e.filter((e=>e.path!==s)),...t].sort(l)}haveMessagesChangedForFile(e,s){if(!e)return s.size>0;if(e.size!==s.size)return!0;for(const[t,a]of e){const e=s.get(t);if(!e||!this.areMessagesEqual(a,e))return!0}return!1}areMessagesEqual(e,s){return e.id===s.id&&e.message===s.message&&e.description===s.description}async save(){return this.saveScheduler.schedule((()=>this.saveImpl()))}async saveImpl(){await this.saveLocale(this.config.sourceLocale);const e=await this.getTargetLocales();await Promise.all(e.map((e=>this.saveLocale(e))))}async saveLocale(e){await this.loadCatalogsPromise;const s=Array.from(this.messagesById.values()),t=await this.getPersister(),a=e===this.config.sourceLocale,o=this.lastWriteByLocale.get(e),i=await t.getLastModified(e);i&&o&&i>o&&await this.reloadLocaleCatalog(e);const r=a?this.messagesById:this.translationsByTargetLocale.get(e),c=s.map((e=>{const s=r?.get(e.id);return{...s,id:e.id,description:e.description,references:e.references,message:a?e.message:s?.message??""}}));await t.write(c,{locale:e,sourceMessagesById:this.messagesById});const l=await t.getLastModified(e);this.lastWriteByLocale.set(e,l)}onLocalesChange=async e=>{this.loadCatalogsPromise=Promise.all([this.loadCatalogsPromise,...e.added.map((e=>this.reloadLocaleCatalog(e)))]);for(const s of e.added)await this.saveLocale(s);for(const s of e.removed)this.translationsByTargetLocale.delete(s),this.lastWriteByLocale.delete(s)};async handleFileEvents(e){this.loadCatalogsPromise&&await this.loadCatalogsPromise,this.scanCompletePromise&&await this.scanCompletePromise;let s=!1;const t=await this.sourceWatcher.expandDirectoryDeleteEvents(e,Array.from(this.messagesByFile.keys()));for(const e of t){const t=await this.processFile(e.path);s||=t}s&&await this.save()}[Symbol.dispose](){this.sourceWatcher?.stop(),this.sourceWatcher=void 0,this.saveScheduler[Symbol.dispose](),this.catalogLocales&&this.isDevelopment&&this.catalogLocales.unsubscribeLocalesChange(this.onLocalesChange)}}export{m as default};

package/dist/esm/production/extractor/catalog/CatalogPersister.js

@@ -0,0 +1 @@
+import e from"fs/promises";import t from"path";class r{constructor(e){this.messagesPath=e.messagesPath,this.codec=e.codec,this.extension=e.extension}getFileName(e){return e+this.extension}getFilePath(e){return t.join(this.messagesPath,this.getFileName(e))}async read(t){const r=this.getFilePath(t);let i;try{i=await e.readFile(r,"utf8")}catch(e){if(e&&"object"==typeof e&&"code"in e&&"ENOENT"===e.code)return[];throw new Error(`Error while reading ${this.getFileName(t)}:\n> ${e}`,{cause:e})}try{return this.codec.decode(i,{locale:t})}catch(e){throw new Error(`Error while decoding ${this.getFileName(t)}:\n> ${e}`,{cause:e})}}async write(r,i){const a=this.getFilePath(i.locale),s=this.codec.encode(r,i);try{const r=t.dirname(a);await e.mkdir(r,{recursive:!0}),await e.writeFile(a,s)}catch(e){console.error(`❌ Failed to write catalog: ${e}`)}}async getLastModified(t){const r=this.getFilePath(t);try{return(await e.stat(r)).mtime}catch{return}}}export{r as default};

package/dist/esm/production/extractor/catalog/SaveScheduler.js

@@ -0,0 +1 @@
+class e{isSaving=!1;pendingResolvers=[];constructor(e=50){this.delayMs=e}async schedule(e){return new Promise(((s,i)=>{this.pendingResolvers.push({resolve:s,reject:i}),this.nextSaveTask=e,this.isSaving||this.saveTimeout?this.saveTimeout&&this.scheduleSave():this.executeSave()}))}scheduleSave(){this.saveTimeout&&clearTimeout(this.saveTimeout),this.saveTimeout=setTimeout((()=>{this.saveTimeout=void 0,this.executeSave()}),this.delayMs)}async executeSave(){if(this.isSaving)return;const e=this.nextSaveTask;if(!e)return;const s=this.pendingResolvers;this.pendingResolvers=[],this.nextSaveTask=void 0,this.isSaving=!0;try{const i=await e();s.forEach((({resolve:e})=>e(i)))}catch(e){s.forEach((({reject:s})=>s(e)))}finally{this.isSaving=!1,this.pendingResolvers.length>0&&this.scheduleSave()}}[Symbol.dispose](){this.saveTimeout&&(clearTimeout(this.saveTimeout),this.saveTimeout=void 0),this.pendingResolvers=[],this.nextSaveTask=void 0,this.isSaving=!1}}export{e as default};

package/dist/esm/production/extractor/catalogLoader.js

@@ -0,0 +1 @@
+import e from"path";import t from"icu-minify/compile";import{getFormatExtension as s,resolveCodec as o}from"./format/index.js";import{setNestedProperty as r}from"./utils.js";let a=null;const n=new Map;function i(i){const c=this.getOptions(),l=this.async(),f=s(c.messages.format);(async function(e,t){return a||(a=await o(e.messages.format,t)),a})(c,this.rootContext).then((s=>{const o=e.basename(this.resourcePath,f);let a;if(c.messages.precompile){const e=function(e,s){const o={},a=new Set(s.keys());for(const n of e){a.delete(n.id);const e=n.message;if(Array.isArray(e))throw new Error(`Message at \`${n.id}\` resolved to an array, but only strings are supported. See https://next-intl.dev/docs/usage/translations#arrays-of-messages`);if("object"==typeof e)throw new Error(`Message at \`${n.id}\` resolved to \`${typeof e}\`, but only strings are supported. Use a \`.\` to retrieve nested messages. See https://next-intl.dev/docs/usage/translations#structuring-messages`);const i=s.get(n.id);let c;i?.messageValue===e?c=i.compiledMessage:(c=t(e),s.set(n.id,{compiledMessage:c,messageValue:e})),r(o,n.id,c)}for(const e of a)s.delete(e);return o}(s.decode(i,{locale:o}),function(e){let t=n.get(e);return t||(t=new Map,n.set(e,t)),t}(this.resourcePath));a=JSON.stringify(e)}else a=s.toJSONString(i,{locale:o});const m=`export default JSON.parse(${JSON.stringify(a)});`;l(null,m)})).catch(l)}export{i as default};

package/dist/esm/production/extractor/extractMessages.js

@@ -0,0 +1 @@
+import t from"./ExtractionCompiler.js";import o from"./extractor/MessageExtractor.js";import{getDefaultProjectRoot as r}from"./utils.js";async function e(e){const a=new t(e,{extractor:new o({isDevelopment:!1,projectRoot:r()})});await a.extractAll()}export{e as default};

package/dist/esm/production/extractor/extractionLoader.js

@@ -0,0 +1 @@
+import t from"./extractor/MessageExtractor.js";let e;function o(o){const r=this.async(),s=this.rootContext,c="development"===process.env["NODE_ENV".trim()];e||(e=new t({isDevelopment:c,projectRoot:s,sourceMap:this.sourceMap})),e.extract(this.resourcePath,o).then((t=>{r(null,t.code,t.map)})).catch(r)}export{o as default};

package/dist/esm/production/extractor/extractor/LRUCache.js

@@ -0,0 +1 @@
+class e{constructor(e){this.maxSize=e,this.cache=new Map}set(e,t){if(!this.cache.has(e)&&this.cache.size>=this.maxSize){const e=this.cache.keys().next().value;void 0!==e&&this.cache.delete(e)}this.cache.set(e,{key:e,value:t})}get(e){const t=this.cache.get(e);if(t)return this.cache.delete(e),this.cache.set(e,t),t.value}}export{e as default};

package/dist/esm/production/extractor/extractor/MessageExtractor.js

@@ -0,0 +1 @@
+import{createRequire as e}from"module";import t from"path";import{transform as s}from"@swc/core";import{getDefaultProjectRoot as o,normalizePathToPosix as r}from"../utils.js";import i from"./LRUCache.js";const c=e(import.meta.url);class a{compileCache=new i(750);constructor(e){this.isDevelopment=e.isDevelopment??!1,this.projectRoot=e.projectRoot??o(),this.sourceMap=e.sourceMap??!1}async extract(e,o){const i=[o,e].join("!"),a=this.compileCache.get(i);if(a)return a;if(!o.includes("useExtracted")&&!o.includes("getExtracted"))return{messages:[],code:o};const p=r(t.relative(this.projectRoot,e)),l=await s(o,{jsc:{target:"esnext",parser:{syntax:"typescript",tsx:!0,decorators:!0},experimental:{cacheRoot:"node_modules/.cache/swc",disableBuiltinTransformsForInternalTesting:!0,disableAllLints:!0,plugins:[[c.resolve("next-intl-swc-plugin-extractor"),{isDevelopment:this.isDevelopment,filePath:p}]]}},sourceMaps:this.sourceMap,sourceFileName:p,filename:p}),n=l.output,m=JSON.parse(JSON.parse(n).results),u={code:l.code,map:l.map,messages:m};return this.compileCache.set(i,u),u}}export{a as default};

package/dist/esm/production/extractor/format/ExtractorCodec.js

@@ -0,0 +1 @@
+function n(n){return n}export{n as defineCodec};

package/dist/esm/production/extractor/format/codecs/JSONCodec.js

@@ -0,0 +1 @@
+import{getSortedMessages as e,setNestedProperty as r}from"../../utils.js";import{defineCodec as s}from"../ExtractorCodec.js";var t=s((()=>({decode(e){const r=JSON.parse(e),s=[];return o(r,((e,r)=>{s.push({id:r,message:e})})),s},encode(s){const t={};for(const o of e(s))r(t,o.id,o.message);return JSON.stringify(t,null,2)+"\n"},toJSONString:e=>e})));function o(e,r,s=""){for(const t of Object.keys(e)){const n=s?s+"."+t:t,a=e[t];if("string"==typeof a)r(a,n);else{if(Array.isArray(a))throw new Error(`Message at \`${n}\` resolved to an array, but only strings are supported. See https://next-intl.dev/docs/usage/translations#arrays-of-messages`);"object"==typeof a&&o(a,r,n)}}}export{t as default};