next-intl 4.11.2 → 4.12.0

package/dist/cjs/development/plugin.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var plugin = require('./plugin-0S9vVrVM.cjs');
+var plugin = require('./plugin-DlFYUFWh.cjs');
 require('fs/promises');
 require('path');
 require('@parcel/watcher');

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

@@ -3,22 +3,34 @@ import path from 'path';
 import { resolveCodec, getFormatExtension } from '../format/index.js';
 import SourceFileScanner from '../source/SourceFileScanner.js';
 import SourceFileWatcher from '../source/SourceFileWatcher.js';
-import { getDefaultProjectRoot, normalizePathToPosix, compareReferences } from '../utils.js';
+import { getDefaultProjectRoot, localeCompare, compareReferences } from '../utils.js';
 import CatalogLocales from './CatalogLocales.js';
 import CatalogPersister from './CatalogPersister.js';
 import SaveScheduler from './SaveScheduler.js';
 
 class CatalogManager {
   /**
-   * The source of truth for which messages are used.
-   * NOTE: Should be mutated in place to keep `messagesById` and `messagesByFile` in sync.
+   * Extraction-derived fields aggregated into `ExtractorMessage`.
+   * Source code is the source of truth for these fields, only ancillary
+   * codec fields may merge from disk (e.g. flags).
    */
-  messagesByFile = new Map();
+  static extractorOwnedAggregatorKeys = new Set(['description', 'id', 'message', 'references']);
+  /**
+   * Source of truth for statically extracted source messages,
+   * grouped by file and message ID.
+   */
+  sourceMessagesByFile = new Map();
+
+  /**
+   * Reverse index for rebuilding aggregated messages without scanning all files.
+   * Contains the same `SourceMessage` arrays as `sourceMessagesByFile` and is
+   * kept in sync with it.
+   */
+  sourceMessagesById = new Map();
 
   /**
-   * Fast lookup for messages by ID across all files,
-   * contains the same messages as `messagesByFile`.
-   * NOTE: Should be mutated in place to keep `messagesById` and `messagesByFile` in sync.
+   * Fast lookup for messages by ID, aggregated across all files. This combines
+   * metadata from `sourceMessagesById`, e.g. references and descriptions.
    */
   messagesById = new Map();
 
@@ -37,7 +49,7 @@ class CatalogManager {
 
   constructor(config, opts) {
     this.config = config;
-    this.saveScheduler = new SaveScheduler(50);
+    this.saveScheduler = new SaveScheduler(opts.saveDebounceMs ?? 50);
     this.projectRoot = opts.projectRoot ?? getDefaultProjectRoot();
     this.isDevelopment = opts.isDevelopment ?? false;
     this.extractor = opts.extractor;
@@ -60,7 +72,7 @@ class CatalogManager {
       return this.persister;
     } else {
       this.persister = new CatalogPersister({
-        messagesPath: this.config.messages.path,
+        messagesPath: this.config.extract.path,
         codec: await this.getCodec(),
         extension: getFormatExtension(this.config.messages.format)
       });
@@ -71,12 +83,12 @@ class CatalogManager {
     if (this.catalogLocales) {
       return this.catalogLocales;
     } else {
-      const messagesDir = path.join(this.projectRoot, this.config.messages.path);
+      const messagesDir = path.join(this.projectRoot, this.config.extract.path);
       this.catalogLocales = new CatalogLocales({
         messagesDir,
-        sourceLocale: this.config.sourceLocale,
         extension: getFormatExtension(this.config.messages.format),
-        locales: this.config.messages.locales
+        locales: this.config.extract.locales,
+        sourceLocale: this.config.extract.sourceLocale
       });
       return this.catalogLocales;
     }
@@ -85,15 +97,28 @@ class CatalogManager {
     return this.getCatalogLocales().getTargetLocales();
   }
   getSrcPaths() {
-    return (Array.isArray(this.config.srcPath) ? this.config.srcPath : [this.config.srcPath]).map(srcPath => path.join(this.projectRoot, srcPath));
+    return (Array.isArray(this.config.extract.srcPath) ? this.config.extract.srcPath : [this.config.extract.srcPath]).map(srcPath => path.join(this.projectRoot, srcPath));
   }
   async loadMessages() {
     const sourceDiskMessages = await this.loadSourceMessages();
     this.loadCatalogsPromise = this.loadTargetMessages();
     await this.loadCatalogsPromise;
     this.scanCompletePromise = (async () => {
-      const sourceFiles = await SourceFileScanner.getSourceFiles(this.getSrcPaths());
-      await Promise.all(Array.from(sourceFiles).map(async filePath => this.processFile(filePath)));
+      const sourceFiles = Array.from(await SourceFileScanner.getSourceFiles(this.getSrcPaths()))
+      // Stable file order keeps catalog ties independent of processing timing
+      .toSorted(localeCompare);
+      const extractedFiles = await Promise.all(sourceFiles.map(async filePath => ({
+        filePath,
+        messages: await this.extractFile(filePath)
+      })));
+      for (const {
+        filePath,
+        messages
+      } of extractedFiles) {
+        if (messages) {
+          this.applyFileMessages(filePath, messages);
+        }
+      }
       this.mergeSourceDiskMetadata(sourceDiskMessages);
     })();
     await this.scanCompletePromise;
@@ -105,7 +130,7 @@ class CatalogManager {
   async loadSourceMessages() {
     // Load source catalog to hydrate metadata (e.g. flags) later without
     // treating catalog entries as source of truth.
-    const diskMessages = await this.loadLocaleMessages(this.config.sourceLocale);
+    const diskMessages = await this.loadLocaleMessages(this.config.extract.sourceLocale);
     const byId = new Map();
     for (const diskMessage of diskMessages) {
       byId.set(diskMessage.id, diskMessage);
@@ -125,17 +150,13 @@ class CatalogManager {
   }
   async reloadLocaleCatalog(locale) {
     const diskMessages = await this.loadLocaleMessages(locale);
-    if (locale === this.config.sourceLocale) {
+    if (locale === this.config.extract.sourceLocale) {
       // For source: Merge additional properties like flags
       for (const diskMessage of diskMessages) {
         const prev = this.messagesById.get(diskMessage.id);
         if (prev) {
-          // Mutate the existing object instead of creating a copy
-          // to keep messagesById and messagesByFile in sync.
-          // Unknown properties (like flags): disk wins
-          // Known properties: existing (from extraction) wins
           for (const key of Object.keys(diskMessage)) {
-            if (!['id', 'message', 'description', 'references'].includes(key)) {
+            if (!CatalogManager.extractorOwnedAggregatorKeys.has(key)) {
               // For unknown properties (like flags), disk wins
               prev[key] = diskMessage[key];
             }
@@ -167,17 +188,23 @@ class CatalogManager {
       const existing = this.messagesById.get(id);
       if (!existing) continue;
 
-      // Mutate the existing object instead of creating a copy.
-      // This keeps `messagesById` and `messagesByFile` in sync since
-      // they reference the same object instance.
+      // Fill unknown metadata from disk without replacing extraction-owned fields.
       for (const key of Object.keys(diskMessage)) {
-        if (existing[key] == null) {
+        if (!CatalogManager.extractorOwnedAggregatorKeys.has(key) && existing[key] == null) {
           existing[key] = diskMessage[key];
         }
       }
     }
   }
   async processFile(absoluteFilePath) {
+    const messages = await this.extractFile(absoluteFilePath);
+
+    // `undefined` only when `extractFile()` throws. An empty array is success
+    // and must still run `applyFileMessages` to clear stale ids for this file.
+    if (!messages) return false;
+    return this.applyFileMessages(absoluteFilePath, messages);
+  }
+  async extractFile(absoluteFilePath) {
     let messages = [];
     try {
       const content = await fs.readFile(absoluteFilePath, 'utf8');
@@ -185,7 +212,7 @@ class CatalogManager {
       try {
         extraction = await this.extractor.extract(absoluteFilePath, content);
       } catch {
-        return false;
+        return undefined;
       }
       messages = extraction.messages;
     } catch (err) {
@@ -194,71 +221,91 @@ class CatalogManager {
       }
       // ENOENT -> treat as no messages
     }
-    const prevFileMessages = this.messagesByFile.get(absoluteFilePath);
-    const relativeFilePath = normalizePathToPosix(path.relative(this.projectRoot, absoluteFilePath));
-
-    // Init with all previous ones
-    const idsToRemove = Array.from(prevFileMessages?.keys() ?? []);
-
-    // Replace existing messages with new ones
-    const fileMessages = new Map();
-    for (let message of messages) {
-      const prevMessage = this.messagesById.get(message.id);
+    return messages;
+  }
+  applyFileMessages(absoluteFilePath, messages) {
+    const prevFileMessages = this.sourceMessagesByFile.get(absoluteFilePath);
+    const nextFileMessages = this.groupSourceMessagesById(messages);
+    const affectedIds = new Set([...(prevFileMessages?.keys() ?? []), ...nextFileMessages.keys()]);
+    if (nextFileMessages.size > 0) {
+      this.sourceMessagesByFile.set(absoluteFilePath, nextFileMessages);
+    } else {
+      this.sourceMessagesByFile.delete(absoluteFilePath);
+    }
 
-      // Merge with previous message if it exists
-      if (prevMessage) {
-        message = {
-          ...message
-        };
-        if (message.references) {
-          message.references = this.mergeReferences(prevMessage.references ?? [], relativeFilePath, message.references);
+    // Clear this file's contribution from the reverse index, then re-insert
+    // fresh rows and rebuild aggregates (messagesById) per touched id.
+    for (const id of affectedIds) {
+      const sourceMessagesForId = this.sourceMessagesById.get(id);
+      if (sourceMessagesForId) {
+        sourceMessagesForId.delete(absoluteFilePath);
+        // No files left for this id: drop the reverse-index entry.
+        if (sourceMessagesForId.size === 0) {
+          this.sourceMessagesById.delete(id);
         }
-
-        // Merge other properties like description, or unknown
-        // attributes like flags that are opaque to us
-        for (const key of Object.keys(prevMessage)) {
-          if (message[key] == null) {
-            message[key] = prevMessage[key];
-          }
+      }
+      const nextSourceMessagesForId = nextFileMessages.get(id);
+      if (nextSourceMessagesForId) {
+        let sourceMessagesByFile = this.sourceMessagesById.get(id);
+        if (!sourceMessagesByFile) {
+          sourceMessagesByFile = new Map();
+          this.sourceMessagesById.set(id, sourceMessagesByFile);
         }
+        sourceMessagesByFile.set(absoluteFilePath, nextSourceMessagesForId);
       }
-      this.messagesById.set(message.id, message);
-      fileMessages.set(message.id, message);
-
-      // This message continues to exist in this file
-      const index = idsToRemove.indexOf(message.id);
-      if (index !== -1) idsToRemove.splice(index, 1);
+      this.rebuildMessageById(id);
     }
-
-    // Clean up removed messages from `messagesById`
-    idsToRemove.forEach(id => {
-      const message = this.messagesById.get(id);
-      if (!message) return;
-      const hasOtherReferences = message.references?.some(ref => ref.path !== relativeFilePath);
-      if (!hasOtherReferences) {
-        // No other references, delete the message entirely
-        this.messagesById.delete(id);
+    const changed = this.haveMessagesChangedForFile(prevFileMessages, nextFileMessages);
+    return changed;
+  }
+  groupSourceMessagesById(messages) {
+    const result = new Map();
+    for (const message of messages) {
+      const messagesById = result.get(message.id);
+      if (messagesById) {
+        messagesById.push(message);
       } else {
-        // Message is used elsewhere, remove this file from references
-        // Mutate the existing object to keep `messagesById` and `messagesByFile` in sync
-        message.references = message.references?.filter(ref => ref.path !== relativeFilePath);
+        result.set(message.id, [message]);
       }
-    });
-
-    // Update the stored messages
-    if (messages.length > 0) {
-      this.messagesByFile.set(absoluteFilePath, fileMessages);
-    } else {
-      this.messagesByFile.delete(absoluteFilePath);
     }
-    const changed = this.haveMessagesChangedForFile(prevFileMessages, fileMessages);
-    return changed;
+    return result;
   }
-  mergeReferences(existing, currentFilePath, currentFileRefs) {
-    // Keep refs from other files, replace all refs from the current file
-    const otherFileRefs = existing.filter(ref => ref.path !== currentFilePath);
-    const merged = [...otherFileRefs, ...currentFileRefs];
-    return merged.sort(compareReferences);
+  rebuildMessageById(id) {
+    const sourceMessages = Array.from(this.sourceMessagesById.get(id)?.values() ?? []).flat();
+    if (sourceMessages.length === 0) {
+      this.messagesById.delete(id);
+      return;
+    }
+    const previousMessage = this.messagesById.get(id);
+    const aggregate = {
+      description: this.mergeDescriptions(sourceMessages),
+      id,
+      message: sourceMessages[0].message,
+      references: sourceMessages.map(message => message.reference).sort(compareReferences)
+    };
+    if (previousMessage) {
+      for (const key of Object.keys(previousMessage)) {
+        // Preserve extra fields (e.g. from disk/codec) across rebuilds; the
+        // four core fields above are always recomputed from source messages.
+        if (!CatalogManager.extractorOwnedAggregatorKeys.has(key) && aggregate[key] == null) {
+          aggregate[key] = previousMessage[key];
+        }
+      }
+    }
+    this.messagesById.set(id, aggregate);
+  }
+  mergeDescriptions(messages) {
+    const sortedByReference = messages.toSorted((a, b) => compareReferences(a.reference, b.reference));
+    const merged = [];
+    for (const message of sortedByReference) {
+      const {
+        description
+      } = message;
+      if (description != null && !merged.includes(description)) {
+        merged.push(description);
+      }
+    }
+    return merged;
   }
   haveMessagesChangedForFile(beforeMessages, afterMessages) {
     // If one exists and the other doesn't, there's a change
@@ -272,25 +319,28 @@ class CatalogManager {
     }
 
     // Check differences in beforeMessages vs afterMessages
-    for (const [id, msg1] of beforeMessages) {
-      const msg2 = afterMessages.get(id);
-      if (!msg2 || !this.areMessagesEqual(msg1, msg2)) {
+    for (const [id, prevSourceMessages] of beforeMessages) {
+      const nextSourceMessages = afterMessages.get(id);
+      if (!nextSourceMessages) {
+        return true;
+      }
+      if (!this.areSourceMessageArraysEqual(prevSourceMessages, nextSourceMessages)) {
         return true; // Early exit on first difference
       }
     }
     return false;
   }
-  areMessagesEqual(msg1, msg2) {
-    // Note: We intentionally don't compare references here.
-    // References are aggregated metadata from multiple files and comparing
-    // them would cause false positives due to parallel extraction order.
-    return msg1.id === msg2.id && msg1.message === msg2.message && msg1.description === msg2.description;
+  areSourceMessageArraysEqual(messages1, messages2) {
+    return messages1.length === messages2.length && messages1.every((message, index) => this.areSourceMessagesEqual(message, messages2[index]));
+  }
+  areSourceMessagesEqual(msg1, msg2) {
+    return msg1.id === msg2.id && msg1.message === msg2.message && msg1.description === msg2.description && msg1.reference.path === msg2.reference.path && msg1.reference.line === msg2.reference.line;
   }
   async save() {
     return this.saveScheduler.schedule(() => this.saveImpl());
   }
   async saveImpl() {
-    await this.saveLocale(this.config.sourceLocale);
+    await this.saveLocale(this.config.extract.sourceLocale);
     const targetLocales = await this.getTargetLocales();
     await Promise.all(targetLocales.map(locale => this.saveLocale(locale)));
   }
@@ -298,7 +348,7 @@ class CatalogManager {
     await this.loadCatalogsPromise;
     const messages = Array.from(this.messagesById.values());
     const persister = await this.getPersister();
-    const isSourceLocale = locale === this.config.sourceLocale;
+    const isSourceLocale = locale === this.config.extract.sourceLocale;
 
     // Check if file was modified externally (poll-at-save is cheaper than
     // watchers here since stat() is fast and avoids continuous overhead)
@@ -348,8 +398,9 @@ class CatalogManager {
       await this.scanCompletePromise;
     }
     let changed = false;
-    const expandedEvents = await this.sourceWatcher.expandDirectoryDeleteEvents(events, Array.from(this.messagesByFile.keys()));
-    for (const event of expandedEvents) {
+    const expandedEvents = await this.sourceWatcher.expandDirectoryDeleteEvents(events, Array.from(this.sourceMessagesByFile.keys()));
+    // Stable file order keeps catalog ties independent of event timing.
+    for (const event of expandedEvents.toSorted((a, b) => localeCompare(a.path, b.path))) {
       const hasChanged = await this.processFile(event.path);
       changed ||= hasChanged;
     }

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

@@ -1,9 +1,16 @@
+import { warn } from '../plugin/utils.js';
 import ExtractionCompiler from './ExtractionCompiler.js';
 import MessageExtractor from './extractor/MessageExtractor.js';
-import { getDefaultProjectRoot } from './utils.js';
+import normalizeExtractorConfig from './normalizeExtractorConfig.js';
+import { hasLocalesToExtract, getDefaultProjectRoot } from './utils.js';
 
 async function extractMessages(params) {
-  const compiler = new ExtractionCompiler(params, {
+  const config = normalizeExtractorConfig(params);
+  if (!hasLocalesToExtract(config)) {
+    warn('`messages.locales` is empty, so no messages were updated.');
+    return;
+  }
+  const compiler = new ExtractionCompiler(config, {
     extractor: new MessageExtractor({
       isDevelopment: false,
       projectRoot: getDefaultProjectRoot()

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

@@ -8,7 +8,9 @@ var JSONCodec = defineCodec(() => ({
     traverseMessages(json, (message, id) => {
       messages.push({
         id,
-        message
+        message,
+        references: [],
+        description: []
       });
     });
     return messages;

package/dist/esm/development/extractor/format/codecs/POCodec.js

@@ -32,41 +32,47 @@ var POCodec = defineCodec(() => {
           msgctxt,
           msgid,
           msgstr,
+          references,
           ...rest
         } = msg;
-        if (extractedComments && extractedComments.length > 1) {
-          throw new Error(`Multiple extracted comments are not supported. Found ${extractedComments.length} comments for msgid "${msgid}".`);
-        }
         return {
           ...rest,
           id: msgctxt ? [msgctxt, msgid].join(NAMESPACE_SEPARATOR) : msgid,
           message: msgstr,
-          ...(extractedComments && extractedComments.length > 0 && {
-            description: extractedComments[0]
-          })
+          description: extractedComments ?? [],
+          references: references ?? []
         };
       });
     },
     encode(messages, context) {
       const encodedMessages = getSortedMessages(messages).map(msg => {
         const {
-          description,
+          description = [],
           id,
           message,
+          references,
           ...rest
         } = msg;
         const lastDotIndex = id.lastIndexOf(NAMESPACE_SEPARATOR);
         const hasNamespace = id.includes(NAMESPACE_SEPARATOR);
         const msgid = hasNamespace ? id.slice(lastDotIndex + NAMESPACE_SEPARATOR.length) : id;
+
+        // Path-only refs (no `:line`), unique paths
+        const pathOnlyRefs = [...new Set(references.map(ref => ref.path))].map(path => ({
+          path
+        }));
         return {
           msgid,
           msgstr: message,
-          ...(description && {
-            extractedComments: [description]
+          ...(description.length > 0 && {
+            extractedComments: description
           }),
           ...(hasNamespace && {
             msgctxt: id.slice(0, lastDotIndex)
           }),
+          ...(pathOnlyRefs.length > 0 && {
+            references: pathOnlyRefs
+          }),
           ...rest
         };
       });

package/dist/esm/development/extractor/normalizeExtractorConfig.js

@@ -0,0 +1,70 @@
+import { throwError, warn } from '../plugin/utils.js';
+
+function stripTrailingSlash(dirPath) {
+  if (dirPath.endsWith('/')) {
+    return dirPath.slice(0, -1);
+  } else {
+    return dirPath;
+  }
+}
+function normalizeMessagesCatalogPaths(messagesPath) {
+  const rawPaths = Array.isArray(messagesPath) ? messagesPath : [messagesPath];
+  return rawPaths.map(dirPath => stripTrailingSlash(String(dirPath).trim())).filter(dirPath => dirPath.length > 0);
+}
+function normalizeExtractorConfig(input) {
+  if (input.messages == null) {
+    throwError('`messages` is required when extracting messages.');
+  }
+  const extract = input.extract;
+  let extractPath;
+  let sourceLocale;
+  if (extract !== undefined && extract !== true) {
+    if (extract.sourceLocale) {
+      warn('`extract.sourceLocale` is deprecated in favor of `messages.sourceLocale`.');
+      sourceLocale = extract.sourceLocale;
+    }
+    if (extract.path) {
+      extractPath = stripTrailingSlash(extract.path);
+    }
+  }
+  const locales = input.messages.locales;
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (!locales) {
+    throwError('`messages.locales` is required when extracting messages.');
+  }
+  if (input.messages.sourceLocale) {
+    sourceLocale = input.messages.sourceLocale;
+  }
+  if (!sourceLocale) {
+    throwError('`messages.sourceLocale` is required when extracting messages.');
+  }
+  const srcPath = input.srcPath;
+  if (srcPath == null) {
+    throwError('`srcPath` is required when extracting messages.');
+  }
+  const pathIsArray = Array.isArray(input.messages.path);
+  const messagesPath = normalizeMessagesCatalogPaths(input.messages.path);
+  if (messagesPath.length === 0) {
+    throwError('`messages.path` must not be empty.');
+  }
+  if (extractPath == null) {
+    if (pathIsArray) {
+      throwError('When `messages.path` is an array, `extract.path` is required to select the writable catalog directory.');
+    }
+    extractPath = messagesPath[0];
+  }
+  return {
+    extract: {
+      locales,
+      path: extractPath,
+      sourceLocale,
+      srcPath
+    },
+    messages: {
+      format: input.messages.format,
+      path: messagesPath
+    }
+  };
+}
+
+export { normalizeExtractorConfig as default, normalizeMessagesCatalogPaths };

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

@@ -23,7 +23,7 @@ class SourceFileWatcher {
         }
         const filtered = await this.normalizeEvents(events);
         if (filtered.length > 0) {
-          void this.onChange(filtered);
+          await this.onChange(filtered);
         }
       }, {
         ignore

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

@@ -1,4 +1,5 @@
 import path from 'path';
+import { warn } from '../plugin/utils.js';
 
 function normalizePathToPosix(filePath) {
   // `path.relative` uses OS-specific separators. For stable `.po` references we
@@ -9,6 +10,12 @@ const FORBIDDEN_OBJECT_KEYS = new Set(['__proto__', 'constructor', 'prototype'])
 function isForbiddenObjectKey(key) {
   return FORBIDDEN_OBJECT_KEYS.has(key);
 }
+function hasLocalesToExtract(config) {
+  const {
+    locales
+  } = config.extract;
+  return locales === 'infer' || locales.length > 0;
+}
 
 // Essentialls lodash/set, but we avoid this dependency
 function setNestedProperty(obj, keyPath, value) {
@@ -29,17 +36,34 @@ function setNestedProperty(obj, keyPath, value) {
   current[keys[keys.length - 1]] = value;
 }
 function getSortedMessages(messages) {
+  const warnedMissingReferenceIds = new Set();
   return messages.toSorted((messageA, messageB) => {
-    const refA = messageA.references?.[0];
-    const refB = messageB.references?.[0];
+    const refA = messageA.references[0];
+    const refB = messageB.references[0];
+
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (refA == null) {
+      warnAboutMissingReference(messageA.id, warnedMissingReferenceIds);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (refB == null) {
+      warnAboutMissingReference(messageB.id, warnedMissingReferenceIds);
+    }
 
-    // No references: preserve original (extraction) order
-    if (!refA || !refB) return 0;
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (refA == null || refB == null) {
+      return 0;
+    }
 
     // Sort by path, then line. Same path+line: preserve original order
     return compareReferences(refA, refB);
   });
 }
+function warnAboutMissingReference(id, warnedMissingReferenceIds) {
+  if (warnedMissingReferenceIds.has(id)) return;
+  warnedMissingReferenceIds.add(id);
+  warn(`Missing file reference for extracted message: ${id}`);
+}
 function localeCompare(a, b) {
   return a.localeCompare(b, 'en');
 }
@@ -52,4 +76,4 @@ function getDefaultProjectRoot() {
   return process.cwd();
 }
 
-export { compareReferences, getDefaultProjectRoot, getSortedMessages, isForbiddenObjectKey, localeCompare, normalizePathToPosix, setNestedProperty };
+export { compareReferences, getDefaultProjectRoot, getSortedMessages, hasLocalesToExtract, isForbiddenObjectKey, localeCompare, normalizePathToPosix, setNestedProperty };

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

@@ -1,3 +1,4 @@
+import normalizeExtractorConfig from '../extractor/normalizeExtractorConfig.js';
 import initExtractionCompiler from './extractor/initExtractionCompiler.js';
 import getNextConfig from './getNextConfig.js';
 import { warn } from './utils.js';
@@ -12,10 +13,20 @@ function initPlugin(pluginConfig, nextConfig) {
   if (messagesPathOrPaths && !skipWatchers) {
     createMessagesDeclaration(typeof messagesPathOrPaths === 'string' ? [messagesPathOrPaths] : messagesPathOrPaths);
   }
+  let extractorConfig;
+  const experimental = pluginConfig.experimental;
+  const extract = experimental?.extract;
+  if (extract) {
+    extractorConfig = normalizeExtractorConfig({
+      extract,
+      messages: experimental.messages,
+      srcPath: experimental.srcPath
+    });
+  }
   if (!skipWatchers) {
-    initExtractionCompiler(pluginConfig);
+    initExtractionCompiler(extractorConfig);
   }
-  return getNextConfig(pluginConfig, nextConfig);
+  return getNextConfig(pluginConfig, nextConfig, extractorConfig);
 }
 function createNextIntlPlugin(i18nPathOrConfig = {}) {
   const config = typeof i18nPathOrConfig === 'string' ? {