next-intl 4.4.0 → 4.5.1

package/dist/esm/development/extractor/formatters/POFormatter.js

@@ -0,0 +1,51 @@
+import { setNestedProperty } from '../utils/ObjectUtils.js';
+import POParser from '../utils/POParser.js';
+import Formatter from './Formatter.js';
+import { getSortedMessages } from './utils.js';
+
+class POFormatter extends Formatter {
+  // See also https://www.gnu.org/software/gettext/manual/html_node/Header-Entry.html
+  static DEFAULT_METADATA = {
+    // Recommended by spec
+    'Content-Type': 'text/plain; charset=utf-8',
+    'Content-Transfer-Encoding': '8bit',
+    // Otherwise other tools might set this
+    'X-Generator': 'next-intl',
+    // Crowdin defaults to using msgid as source key
+    'X-Crowdin-SourceKey': 'msgstr'
+  };
+  EXTENSION = '.po';
+
+  // Metadata is stored so it can be retained when writing
+  metadataByLocale = (() => new Map())();
+  parse(content, context) {
+    const catalog = POParser.parse(content);
+
+    // Store metadata for this locale
+    if (catalog.meta) {
+      this.metadataByLocale.set(context.locale, catalog.meta);
+    }
+    return catalog.messages || [];
+  }
+  serialize(messages, context) {
+    const meta = {
+      Language: context.locale,
+      ...POFormatter.DEFAULT_METADATA,
+      ...this.metadataByLocale.get(context.locale)
+    };
+    return POParser.serialize({
+      meta,
+      messages: getSortedMessages(messages)
+    });
+  }
+  toJSONString(source, context) {
+    const parsed = this.parse(source, context);
+    const messagesObject = {};
+    for (const message of parsed) {
+      setNestedProperty(messagesObject, message.id, message.message);
+    }
+    return JSON.stringify(messagesObject, null, 2);
+  }
+}
+
+export { POFormatter as default };

package/dist/esm/development/extractor/formatters/index.js

@@ -0,0 +1,6 @@
+const formatters = {
+  json: () => import('./JSONFormatter.js'),
+  po: () => import('./POFormatter.js')
+};
+
+export { formatters as default };

package/dist/esm/development/extractor/formatters/utils.js

@@ -0,0 +1,13 @@
+function getSortedMessages(messages) {
+  return messages.toSorted((a, b) => {
+    const aPath = a.references?.[0]?.path ?? a.message;
+    const bPath = b.references?.[0]?.path ?? b.message;
+    if (aPath === bPath) {
+      return a.message.localeCompare(b.message);
+    } else {
+      return aPath.localeCompare(bPath);
+    }
+  });
+}
+
+export { getSortedMessages };

package/dist/esm/development/extractor/source/SourceFileFilter.js

@@ -0,0 +1,11 @@
+import path from 'path';
+
+class SourceFileFilter {
+  static EXTENSIONS = ['ts', 'tsx', 'js', 'jsx'];
+  static isSourceFile(filePath) {
+    const ext = path.extname(filePath);
+    return SourceFileFilter.EXTENSIONS.map(cur => '.' + cur).includes(ext);
+  }
+}
+
+export { SourceFileFilter as default };

package/dist/esm/development/extractor/source/SourceFileScanner.js

@@ -0,0 +1,27 @@
+import fs from 'fs/promises';
+import path from 'path';
+import SourceFileFilter from './SourceFileFilter.js';
+
+class SourceFileScanner {
+  static async walkSourceFiles(dir, srcPaths, acc = []) {
+    const entries = await fs.readdir(dir, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      const entryPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await SourceFileScanner.walkSourceFiles(entryPath, srcPaths, acc);
+      } else {
+        if (SourceFileFilter.isSourceFile(entry.name)) {
+          acc.push(entryPath);
+        }
+      }
+    }
+    return acc;
+  }
+  static async getSourceFiles(srcPaths) {
+    return (await Promise.all(srcPaths.map(srcPath => SourceFileScanner.walkSourceFiles(srcPath, srcPaths)))).flat();
+  }
+}
+
+export { SourceFileScanner as default };

package/dist/esm/development/extractor/utils/ObjectUtils.js

@@ -0,0 +1,14 @@
+function setNestedProperty(obj, keyPath, value) {
+  const keys = keyPath.split('.');
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current) || typeof current[key] !== 'object' || current[key] === null) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+}
+
+export { setNestedProperty };

package/dist/esm/development/extractor/utils/POParser.js

@@ -0,0 +1,222 @@
+class POParser {
+  static KEYWORDS = (() => ({
+    MSGID: 'msgid',
+    MSGSTR: 'msgstr',
+    MSGCTXT: 'msgctxt',
+    MSGID_PLURAL: 'msgid_plural'
+  }))();
+  static COMMENTS = (() => ({
+    REFERENCE: '#:',
+    EXTRACTED: '#.',
+    TRANSLATOR: '#',
+    FLAG: '#,',
+    PREVIOUS: '#|'
+  }))();
+  static NAMESPACE_SEPARATOR = '.';
+  static QUOTE = '"';
+  static NEWLINE = '\\n';
+  static FILE_COLUMN_SEPARATOR = ':';
+  static META_SEPARATOR = ':';
+  static parse(content) {
+    const lines = POParser.splitLines(content);
+    const messages = [];
+    const meta = {};
+    let state = 'entry';
+    let entry;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+
+      // An empty line indicates the end of an entry
+      if (!line) {
+        if (state === 'entry' && entry) {
+          messages.push(POParser.finishEntry(entry));
+          entry = undefined;
+        }
+        state = 'entry';
+        continue;
+      }
+      if (state === 'meta') {
+        if (line.startsWith(POParser.QUOTE)) {
+          const metaLine = POParser.extractQuotedString(line, state);
+          const cleaned = metaLine.endsWith(POParser.NEWLINE) ? metaLine.slice(0, -2) : metaLine;
+          const separatorIndex = cleaned.indexOf(POParser.META_SEPARATOR);
+          if (separatorIndex > 0) {
+            const key = cleaned.substring(0, separatorIndex).trim();
+            const value = cleaned.substring(separatorIndex + 1).trim();
+            meta[key] = value;
+          }
+        } else {
+          POParser.throwWithLine('Encountered unexpected non-quoted metadata line', line);
+        }
+      } else {
+        // Unsupported comment types
+        if (POParser.lineStartsWithPrefix(line, POParser.COMMENTS.TRANSLATOR)) {
+          POParser.throwWithLine('Translator comments (#) are not supported, use inline descriptions instead', line);
+        }
+        if (POParser.lineStartsWithPrefix(line, POParser.COMMENTS.FLAG)) {
+          POParser.throwWithLine('Flag comments (#,) are not supported', line);
+        }
+        if (POParser.lineStartsWithPrefix(line, POParser.COMMENTS.PREVIOUS)) {
+          POParser.throwWithLine('Previous string key comments (#|) are not supported', line);
+        }
+
+        // Reference comments
+        if (POParser.lineStartsWithPrefix(line, POParser.COMMENTS.REFERENCE)) {
+          entry = POParser.ensureEntry(entry);
+          // Only use the path part, ignore line and column numbers
+          const path = line.substring(POParser.COMMENTS.REFERENCE.length).trim().split(POParser.FILE_COLUMN_SEPARATOR).at(0);
+          entry.references ??= [];
+          entry.references.push({
+            path
+          });
+          continue;
+        }
+
+        // Extracted comments
+        if (POParser.lineStartsWithPrefix(line, POParser.COMMENTS.EXTRACTED)) {
+          entry = POParser.ensureEntry(entry);
+          entry.description = line.substring(POParser.COMMENTS.EXTRACTED.length).trim();
+          continue;
+        }
+
+        // Check for unsupported features
+        if (POParser.lineStartsWithPrefix(line, POParser.KEYWORDS.MSGID_PLURAL)) {
+          POParser.throwWithLine('Plural forms (msgid_plural) are not supported, use ICU pluralization instead', line);
+        }
+
+        // msgctxt
+        if (POParser.lineStartsWithPrefix(line, POParser.KEYWORDS.MSGCTXT)) {
+          entry = POParser.ensureEntry(entry);
+          entry.msgctxt = POParser.extractQuotedString(line.substring(POParser.KEYWORDS.MSGCTXT.length + 1), state);
+          continue;
+        }
+
+        // msgid
+        if (POParser.lineStartsWithPrefix(line, POParser.KEYWORDS.MSGID)) {
+          entry = POParser.ensureEntry(entry);
+          entry.msgid = POParser.extractQuotedString(line.substring(POParser.KEYWORDS.MSGID.length + 1), state);
+          if (POParser.isMetaEntry(entry, messages)) {
+            state = 'meta';
+            entry = undefined;
+          }
+          continue;
+        }
+
+        // msgstr
+        if (POParser.lineStartsWithPrefix(line, POParser.KEYWORDS.MSGSTR)) {
+          entry = POParser.ensureEntry(entry);
+          entry.msgstr = POParser.extractQuotedString(line.substring(POParser.KEYWORDS.MSGSTR.length + 1), state);
+          if (POParser.isMetaEntry(entry, messages)) {
+            state = 'meta';
+            entry = undefined;
+          }
+          continue;
+        }
+
+        // Multi-line strings are not supported in entry mode
+        if (line.startsWith(POParser.QUOTE)) {
+          POParser.throwWithLine('Multi-line strings are not supported, use single-line strings instead', line);
+        }
+      }
+    }
+
+    // Finish any remaining entry
+    if (state === 'entry' && entry) {
+      messages.push(POParser.finishEntry(entry));
+    }
+    return {
+      meta: Object.keys(meta).length > 0 ? meta : undefined,
+      messages: messages.length > 0 ? messages : undefined
+    };
+  }
+  static isMetaEntry(entry, messages) {
+    return messages.length === 0 && entry.msgid === '' && entry.msgstr === '';
+  }
+  static serialize(catalog) {
+    const lines = [];
+
+    // Metadata
+    if (catalog.meta) {
+      lines.push(`${POParser.KEYWORDS.MSGID} ${POParser.QUOTE}${POParser.QUOTE}`);
+      lines.push(`${POParser.KEYWORDS.MSGSTR} ${POParser.QUOTE}${POParser.QUOTE}`);
+      for (const [key, value] of Object.entries(catalog.meta)) {
+        lines.push(`${POParser.QUOTE}${key}${POParser.META_SEPARATOR} ${value}${POParser.NEWLINE}${POParser.QUOTE}`);
+      }
+      lines.push('');
+    }
+
+    // Messages
+    if (catalog.messages) {
+      for (const message of catalog.messages) {
+        if (message.description) {
+          lines.push(`${POParser.COMMENTS.EXTRACTED} ${message.description}`);
+        }
+        if (message.references && message.references.length > 0) {
+          for (const ref of message.references) {
+            lines.push(`${POParser.COMMENTS.REFERENCE} ${ref.path}`);
+          }
+        }
+        let msgctxt;
+        let msgid;
+        const lastDotIndex = message.id.lastIndexOf(POParser.NAMESPACE_SEPARATOR);
+        if (lastDotIndex > 0) {
+          msgctxt = message.id.substring(0, lastDotIndex);
+          msgid = message.id.substring(lastDotIndex + 1);
+        } else {
+          msgid = message.id;
+        }
+        if (msgctxt) {
+          lines.push(`${POParser.KEYWORDS.MSGCTXT} ${POParser.QUOTE}${msgctxt}${POParser.QUOTE}`);
+        }
+        lines.push(`${POParser.KEYWORDS.MSGID} ${POParser.QUOTE}${msgid}${POParser.QUOTE}`);
+        lines.push(`${POParser.KEYWORDS.MSGSTR} ${POParser.QUOTE}${message.message}${POParser.QUOTE}`);
+        lines.push('');
+      }
+    }
+    return lines.join('\n');
+  }
+  static lineStartsWithPrefix(line, prefix) {
+    return line.startsWith(prefix + ' ');
+  }
+  static throwWithLine(message, line) {
+    throw new Error(`${message}:\n> ${line}`);
+  }
+  static splitLines(content) {
+    // Avoid overhead for Unix newlines only
+    if (content.includes('\r')) {
+      content = content.replace(/\r\n/g, '\n');
+    }
+    return content.split('\n');
+  }
+  static ensureEntry(entry) {
+    return entry || {};
+  }
+  static finishEntry(entry) {
+    if (entry.msgid == null || entry.msgstr == null) {
+      throw new Error('Incomplete message entry: both msgid and msgstr are required');
+    }
+    let fullId = entry.msgid;
+    if (entry.msgctxt) {
+      fullId = entry.msgctxt + POParser.NAMESPACE_SEPARATOR + entry.msgid;
+    }
+    return {
+      id: fullId,
+      message: entry.msgstr,
+      description: entry.description,
+      references: entry.references
+    };
+  }
+  static extractQuotedString(line, state) {
+    const trimmed = line.trim();
+    const endIndex = trimmed.indexOf(POParser.QUOTE, POParser.QUOTE.length);
+    if (endIndex === -1) {
+      if (state === 'meta') {
+        return trimmed.substring(POParser.QUOTE.length);
+      }
+      POParser.throwWithLine('Incomplete quoted string', line);
+    }
+    return trimmed.substring(POParser.QUOTE.length, endIndex);
+  }
+}
+
+export { POParser as default };

package/dist/esm/development/extractor.js

@@ -0,0 +1 @@
+export { default as unstable_extractMessages } from './extractor/extractMessages.js';

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

@@ -1,3 +1,4 @@
 export { useFormatter, useTranslations } from './react-client/index.js';
 export { default as NextIntlClientProvider } from './shared/NextIntlClientProvider.js';
-export * from 'use-intl';
+export { IntlProvider, _useExtracted as useExtracted, useLocale, useMessages, useNow, useTimeZone } from 'use-intl/react';
+export * from 'use-intl/core';

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

@@ -5,4 +5,5 @@ export { default as useNow } from './react-server/useNow.js';
 export { default as useTimeZone } from './react-server/useTimeZone.js';
 export { default as useMessages } from './react-server/useMessages.js';
 export { default as NextIntlClientProvider } from './react-server/NextIntlClientProviderServer.js';
+export { default as useExtracted } from './react-server/useExtracted.js';
 export * from 'use-intl/core';

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

@@ -121,9 +121,13 @@ function getRouteParams(template, pathname) {
   const match = regex.exec(normalizedPathname);
   if (!match) return undefined;
   const params = {};
+  const keys = normalizedTemplate.match(/\[([^\]]+)\]/g) ?? [];
   for (let i = 1; i < match.length; i++) {
-    const key = normalizedTemplate.match(/\[([^\]]+)\]/g)?.[i - 1].replace(/[[\]]/g, '');
-    if (key) params[key] = match[i];
+    const rawKey = keys[i - 1];
+    if (!rawKey) continue;
+    const key = rawKey.replace(/[[\]]/g, '');
+    const value = match[i] ?? '';
+    params[key] = value;
   }
   return params;
 }

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

@@ -1,6 +1,6 @@
-import createMessagesDeclaration from './createMessagesDeclaration.js';
 import getNextConfig from './getNextConfig.js';
 import { warn } from './utils.js';
+import createMessagesDeclaration from './declaration/createMessagesDeclaration.js';
 
 function initPlugin(pluginConfig, nextConfig) {
   if (nextConfig?.i18n != null) {

package/dist/esm/development/plugin/{createMessagesDeclaration.js → declaration/createMessagesDeclaration.js}

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
-import { throwError } from './utils.js';
-import watchFile from './watchFile.js';
+import { throwError } from '../utils.js';
+import watchFile from '../watchFile.js';
 
 function runOnce(fn) {
   if (process.env._NEXT_INTL_COMPILE_MESSAGES === '1') {

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

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
-import hasStableTurboConfig from './hasStableTurboConfig.js';
+import SourceFileFilter from '../extractor/source/SourceFileFilter.js';
+import { isNextJs16OrHigher, hasStableTurboConfig } from './nextFlags.js';
 import { throwError } from './utils.js';
 
 function withExtensions(localPath) {
@@ -39,22 +40,99 @@ const withNextIntl = createNextIntlPlugin(
 function getNextConfig(pluginConfig, nextConfig) {
   const useTurbo = process.env.TURBOPACK != null;
   const nextIntlConfig = {};
-
-  // Assign alias for `next-intl/config`
+  function getExtractMessagesLoaderConfig() {
+    const experimental = pluginConfig.experimental;
+    if (!experimental.srcPath || !experimental.messages) {
+      throwError('`srcPath` and `messages` are required when using `extractor`.');
+    }
+    return {
+      loader: 'next-intl/extractor/extractionLoader',
+      options: {
+        srcPath: experimental.srcPath,
+        sourceLocale: experimental.extract.sourceLocale,
+        messages: experimental.messages
+      }
+    };
+  }
+  function getCatalogLoaderConfig() {
+    return {
+      loader: 'next-intl/extractor/catalogLoader',
+      options: {
+        messages: pluginConfig.experimental.messages
+      }
+    };
+  }
+  function getTurboRules() {
+    return nextConfig?.turbopack?.rules ||
+    // @ts-expect-error -- For Next.js <16
+    nextConfig?.experimental?.turbo?.rules || {};
+  }
+  function addTurboRule(rules, glob, rule) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (rules[glob]) {
+      if (Array.isArray(rules[glob])) {
+        rules[glob].push(rule);
+      } else {
+        rules[glob] = [rules[glob], rule];
+      }
+    } else {
+      rules[glob] = rule;
+    }
+  }
   if (useTurbo) {
-    if (pluginConfig.requestConfig?.startsWith('/')) {
+    if (pluginConfig.requestConfig && path.isAbsolute(pluginConfig.requestConfig)) {
       throwError("Turbopack support for next-intl currently does not support absolute paths, please provide a relative one (e.g. './src/i18n/config.ts').\n\nFound: " + pluginConfig.requestConfig);
     }
+
+    // Assign alias for `next-intl/config`
     const resolveAlias = {
       // Turbo aliases don't work with absolute
       // paths (see error handling above)
       'next-intl/config': resolveI18nPath(pluginConfig.requestConfig)
     };
-    if (hasStableTurboConfig &&
+
+    // Add loaders
+    let rules;
+
+    // Add loader for extractor
+    if (pluginConfig.experimental?.extract) {
+      if (!isNextJs16OrHigher()) {
+        throwError('Message extraction requires Next.js 16 or higher.');
+      }
+      rules ??= getTurboRules();
+      addTurboRule(rules, `*.{${SourceFileFilter.EXTENSIONS.join(',')}}`, {
+        loaders: [getExtractMessagesLoaderConfig()],
+        condition: {
+          // Note: We don't need `not: 'foreign'`, because this is
+          // implied by the filter based on `srcPath`.
+          path: (Array.isArray(pluginConfig.experimental.srcPath) ? `{${pluginConfig.experimental.srcPath.join(',')}}` : pluginConfig.experimental.srcPath) + '/**/*',
+          content: /(useExtracted|getExtracted)/
+        }
+      });
+    }
+
+    // Add loader for catalog
+    if (pluginConfig.experimental?.messages) {
+      if (!isNextJs16OrHigher()) {
+        throwError('Message catalog loading requires Next.js 16 or higher.');
+      }
+      rules ??= getTurboRules();
+      addTurboRule(rules, `*.${pluginConfig.experimental.messages.format}`, {
+        loaders: [getCatalogLoaderConfig()],
+        condition: {
+          path: `${pluginConfig.experimental.messages.path}/**/*`
+        },
+        as: '*.js'
+      });
+    }
+    if (hasStableTurboConfig() &&
     // @ts-expect-error -- For Next.js <16
     !nextConfig?.experimental?.turbo) {
       nextIntlConfig.turbopack = {
         ...nextConfig?.turbopack,
+        ...(rules && {
+          rules
+        }),
         resolveAlias: {
           ...nextConfig?.turbopack?.resolveAlias,
           ...resolveAlias
@@ -67,6 +145,9 @@ function getNextConfig(pluginConfig, nextConfig) {
         turbo: {
           // @ts-expect-error -- For Next.js <16
           ...nextConfig?.experimental?.turbo,
+          ...(rules && {
+            rules
+          }),
           resolveAlias: {
             // @ts-expect-error -- For Next.js <16
             ...nextConfig?.experimental?.turbo?.resolveAlias,
@@ -76,11 +157,39 @@ function getNextConfig(pluginConfig, nextConfig) {
       };
     }
   } else {
-    nextIntlConfig.webpack = function webpack(...[config, options]) {
-      // Webpack requires absolute paths
+    nextIntlConfig.webpack = function webpack(config, context) {
+      if (!config.resolve) config.resolve = {};
+      if (!config.resolve.alias) config.resolve.alias = {};
+
+      // Assign alias for `next-intl/config`
+      // (Webpack requires absolute paths)
       config.resolve.alias['next-intl/config'] = path.resolve(config.context, resolveI18nPath(pluginConfig.requestConfig, config.context));
+
+      // Add loader for extractor
+      if (pluginConfig.experimental?.extract) {
+        if (!config.module) config.module = {};
+        if (!config.module.rules) config.module.rules = [];
+        const srcPath = pluginConfig.experimental.srcPath;
+        config.module.rules.push({
+          test: new RegExp(`\\.(${SourceFileFilter.EXTENSIONS.join('|')})$`),
+          include: Array.isArray(srcPath) ? srcPath.map(cur => path.resolve(config.context, cur)) : path.resolve(config.context, srcPath || ''),
+          use: [getExtractMessagesLoaderConfig()]
+        });
+      }
+
+      // Add loader for catalog
+      if (pluginConfig.experimental?.messages) {
+        if (!config.module) config.module = {};
+        if (!config.module.rules) config.module.rules = [];
+        config.module.rules.push({
+          test: new RegExp(`\\.${pluginConfig.experimental.messages.format}$`),
+          include: path.resolve(config.context, pluginConfig.experimental.messages.path),
+          use: [getCatalogLoaderConfig()],
+          type: 'javascript/auto'
+        });
+      }
       if (typeof nextConfig?.webpack === 'function') {
-        return nextConfig.webpack(config, options);
+        return nextConfig.webpack(config, context);
       }
       return config;
     };

package/dist/esm/development/plugin/{hasStableTurboConfig.js → nextFlags.js}

@@ -22,6 +22,11 @@ function compareVersions(version1, version2) {
   }
   return 0;
 }
-const hasStableTurboConfig = compareVersions(getCurrentVersion(), '15.3.0') >= 0;
+function hasStableTurboConfig() {
+  return compareVersions(getCurrentVersion(), '15.3.0') >= 0;
+}
+function isNextJs16OrHigher() {
+  return compareVersions(getCurrentVersion(), '16.0.0') >= 0;
+}
 
-export { hasStableTurboConfig as default };
+export { hasStableTurboConfig, isNextJs16OrHigher };

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

@@ -1,5 +1,4 @@
 import { useFormatter as useFormatter$1, useTranslations as useTranslations$1 } from 'use-intl';
-export * from 'use-intl';
 
 /**
  * This is the main entry file when non-'react-server'

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

@@ -0,0 +1,9 @@
+import getServerExtractor from '../server/react-server/getServerExtractor.js';
+import useConfig from './useConfig.js';
+
+function useExtracted(namespace) {
+  const config = useConfig('useExtracted');
+  return getServerExtractor(config, namespace);
+}
+
+export { useExtracted as default };

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

@@ -21,6 +21,7 @@ const getNow = notSupported('getNow');
 const getTimeZone = notSupported('getTimeZone');
 const getMessages = notSupported('getMessages');
 const getLocale = notSupported('getLocale');
+const getExtracted = notSupported('getExtracted');
 
 // The type of `getTranslations` is not assigned here because it
 // causes a type error. The types use the `react-server` entry
@@ -28,4 +29,4 @@ const getLocale = notSupported('getLocale');
 const getTranslations = notSupported('getTranslations');
 const setRequestLocale = notSupported('setRequestLocale');
 
-export { getFormatter, getLocale, getMessages, getNow, getRequestConfig, getTimeZone, getTranslations, setRequestLocale };
+export { getExtracted, getFormatter, getLocale, getMessages, getNow, getRequestConfig, getTimeZone, getTranslations, setRequestLocale };

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 };