next-intl 4.4.0 → 4.5.1

package/dist/cjs/development/plugin.cjs

@@ -105,6 +105,14 @@ export default messages;`;
   fs.writeFileSync(declarationPath, createDeclaration(content));
 }
 
+class SourceFileFilter {
+  static EXTENSIONS = ['ts', 'tsx', 'js', 'jsx'];
+  static isSourceFile(filePath) {
+    const ext = path.extname(filePath);
+    return SourceFileFilter.EXTENSIONS.map(cur => '.' + cur).includes(ext);
+  }
+}
+
 function getCurrentVersion() {
   try {
     const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('plugin.cjs', document.baseURI).href)));
@@ -127,7 +135,12 @@ 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;
+}
 
 function withExtensions(localPath) {
   return [`${localPath}.ts`, `${localPath}.tsx`, `${localPath}.js`, `${localPath}.jsx`];
@@ -165,22 +178,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
@@ -193,6 +283,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,
@@ -202,11 +295,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/extractor/ExtractionCompiler.js

@@ -0,0 +1,41 @@
+import CatalogManager from './catalog/CatalogManager.js';
+
+class ExtractionCompiler {
+  isDevelopment = false;
+  constructor(config, opts = {}) {
+    this.manager = new CatalogManager(config, opts);
+    this.isDevelopment = opts.isDevelopment ?? false;
+
+    // Kick off the initial scan as early as possible,
+    // while awaiting it in `compile`. This also ensures
+    // we're only scanning once.
+    this.initialScanPromise = this.performInitialScan();
+  }
+  async compile(resourcePath, source) {
+    if (this.initialScanPromise) {
+      await this.initialScanPromise;
+      this.initialScanPromise = undefined;
+    }
+    const result = await this.manager.extractFileMessages(resourcePath, source);
+    if (this.isDevelopment && result.changed) {
+      // While we await the AST modification, we
+      // don't need to await the persistence
+      void this.manager.save();
+    }
+    return result.source;
+  }
+  async performInitialScan() {
+    // We can't rely on all files being compiled (e.g. due to persistent
+    // caching), so loading the messages initially is necessary.
+    await this.manager.loadMessages();
+    await this.manager.save();
+  }
+  async extract() {
+    await this.initialScanPromise;
+  }
+  [Symbol.dispose]() {
+    this.manager.destroy();
+  }
+}
+
+export { ExtractionCompiler as default };

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

@@ -0,0 +1,117 @@
+import fs$1 from 'fs';
+import fs from 'fs/promises';
+import path from 'path';
+
+class CatalogLocales {
+  cleanupHandlers = [];
+  onChangeCallbacks = (() => new Set())();
+  constructor(params) {
+    this.messagesDir = params.messagesDir;
+    this.sourceLocale = params.sourceLocale;
+    this.extension = params.extension;
+    this.locales = params.locales;
+  }
+  async getTargetLocales() {
+    if (this.targetLocales) {
+      return this.targetLocales;
+    }
+    if (this.locales === 'infer') {
+      this.targetLocales = await this.readTargetLocales();
+    } else {
+      this.targetLocales = this.locales.filter(locale => locale !== this.sourceLocale);
+    }
+    return this.targetLocales;
+  }
+  async readTargetLocales() {
+    try {
+      const files = await fs.readdir(this.messagesDir);
+      return files.filter(file => file.endsWith(this.extension)).map(file => path.basename(file, this.extension)).filter(locale => locale !== this.sourceLocale);
+    } catch {
+      return [];
+    }
+  }
+  subscribeLocalesChange(callback) {
+    this.onChangeCallbacks.add(callback);
+    if (this.locales === 'infer' && !this.watcher) {
+      void this.startWatcher();
+    }
+  }
+  unsubscribeLocalesChange(callback) {
+    this.onChangeCallbacks.delete(callback);
+    if (this.onChangeCallbacks.size === 0) {
+      this.stopWatcher();
+    }
+  }
+  async startWatcher() {
+    if (this.watcher) {
+      return;
+    }
+    await fs.mkdir(this.messagesDir, {
+      recursive: true
+    });
+    this.watcher = fs$1.watch(this.messagesDir, {
+      persistent: false,
+      recursive: false
+    }, (event, filename) => {
+      const isCatalogFile = filename != null && filename.endsWith(this.extension) && !filename.includes(path.sep);
+      if (isCatalogFile) {
+        void this.onChange();
+      }
+    });
+    this.setupCleanupHandlers();
+  }
+  stopWatcher() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = undefined;
+    }
+    for (const handler of this.cleanupHandlers) {
+      handler();
+    }
+    this.cleanupHandlers = [];
+  }
+  async onChange() {
+    const oldLocales = new Set(this.targetLocales || []);
+    this.targetLocales = await this.readTargetLocales();
+    const newLocalesSet = new Set(this.targetLocales);
+    const added = this.targetLocales.filter(locale => !oldLocales.has(locale));
+    const removed = Array.from(oldLocales).filter(locale => !newLocalesSet.has(locale));
+    if (added.length > 0 || removed.length > 0) {
+      for (const callback of this.onChangeCallbacks) {
+        callback({
+          added,
+          removed
+        });
+      }
+    }
+  }
+  setupCleanupHandlers() {
+    const cleanup = () => {
+      if (this.watcher) {
+        this.watcher.close();
+        this.watcher = undefined;
+      }
+    };
+    function exitHandler() {
+      cleanup();
+    }
+    function sigintHandler() {
+      cleanup();
+      process.exit(0);
+    }
+    function sigtermHandler() {
+      cleanup();
+      process.exit(0);
+    }
+    process.once('exit', exitHandler);
+    process.once('SIGINT', sigintHandler);
+    process.once('SIGTERM', sigtermHandler);
+    this.cleanupHandlers.push(() => {
+      process.removeListener('exit', exitHandler);
+      process.removeListener('SIGINT', sigintHandler);
+      process.removeListener('SIGTERM', sigtermHandler);
+    });
+  }
+}
+
+export { CatalogLocales as default };

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

@@ -0,0 +1,286 @@
+import fs from 'fs/promises';
+import path from 'path';
+import MessageExtractor from '../extractor/MessageExtractor.js';
+import formatters from '../formatters/index.js';
+import SourceFileScanner from '../source/SourceFileScanner.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. */
+  messagesByFile = (() => new Map())();
+
+  /* Fast lookup for messages by ID across all files,
+   * contains the same messages as `messagesByFile`. */
+  messagesById = (() => new Map())();
+
+  /**
+   * This potentially also includes outdated ones that were initially available,
+   * but are not used anymore. This allows to restore them if they are used again.
+   **/
+  translationsByTargetLocale = (() => new Map())();
+  lastWriteByLocale = (() => new Map())();
+
+  // Cached instances
+
+  constructor(config, opts = {}) {
+    this.config = config;
+    this.saveScheduler = new SaveScheduler(50);
+    this.projectRoot = opts.projectRoot || process.cwd();
+    this.isDevelopment = opts.isDevelopment ?? false;
+    this.messageExtractor = new MessageExtractor({
+      isDevelopment: this.isDevelopment,
+      projectRoot: this.projectRoot
+    });
+  }
+  async getFormatter() {
+    if (this.formatter) {
+      return this.formatter;
+    } else {
+      const FormatterClass = (await formatters[this.config.messages.format]()).default;
+      this.formatter = new FormatterClass();
+      return this.formatter;
+    }
+  }
+  async getPersister() {
+    if (this.persister) {
+      return this.persister;
+    } else {
+      this.persister = new CatalogPersister(this.config.messages.path, await this.getFormatter());
+      return this.persister;
+    }
+  }
+  async getCatalogLocales() {
+    if (this.catalogLocales) {
+      return this.catalogLocales;
+    } else {
+      const messagesDir = path.join(this.projectRoot, this.config.messages.path);
+      const formatter = await this.getFormatter();
+      this.catalogLocales = new CatalogLocales({
+        messagesDir,
+        sourceLocale: this.config.sourceLocale,
+        extension: formatter.EXTENSION,
+        locales: this.config.messages.locales
+      });
+      return this.catalogLocales;
+    }
+  }
+  async getTargetLocales() {
+    const catalogLocales = await this.getCatalogLocales();
+    return catalogLocales.getTargetLocales();
+  }
+  getSrcPaths() {
+    return (Array.isArray(this.config.srcPath) ? this.config.srcPath : [this.config.srcPath]).map(srcPath => path.join(this.projectRoot, srcPath));
+  }
+  getFileMessages(absoluteFilePath) {
+    return this.messagesByFile.get(absoluteFilePath);
+  }
+  async loadMessages() {
+    await this.loadSourceMessages();
+    await this.loadTargetMessages();
+    if (this.isDevelopment) {
+      const catalogLocales = await this.getCatalogLocales();
+      catalogLocales.subscribeLocalesChange(this.onLocalesChange);
+    }
+  }
+  async loadSourceMessages() {
+    // First hydrate from source locale file to potentially init metadata
+    await this.loadLocaleMessages(this.config.sourceLocale);
+
+    // Then extract from all source files
+    const sourceFiles = await SourceFileScanner.getSourceFiles(this.getSrcPaths());
+    await Promise.all(sourceFiles.map(async filePath => this.extractFileMessages(filePath, await fs.readFile(filePath, 'utf8'))));
+  }
+  async loadLocaleMessages(locale) {
+    const persister = await this.getPersister();
+    try {
+      const messages = await persister.read(locale);
+      const fileTime = await persister.getLastModified(locale);
+      this.lastWriteByLocale.set(locale, fileTime);
+      return messages;
+    } catch {
+      return [];
+    }
+  }
+  async loadTargetMessages() {
+    const targetLocales = await this.getTargetLocales();
+    await Promise.all(targetLocales.map(async locale => {
+      this.translationsByTargetLocale.set(locale, new Map());
+      const messages = await this.loadLocaleMessages(locale);
+      for (const message of messages) {
+        const translations = this.translationsByTargetLocale.get(locale);
+        translations.set(message.id, message.message);
+      }
+    }));
+  }
+  async extractFileMessages(absoluteFilePath, source) {
+    const result = await this.messageExtractor.processFileContent(absoluteFilePath, source);
+    const prevFileMessages = this.messagesByFile.get(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 result.messages) {
+      const prevMessage = this.messagesById.get(message.id);
+
+      // Merge with previous message if it exists
+      if (prevMessage) {
+        // References: The `message` we receive here will always have one
+        // reference, which is the current file. We need to merge this with
+        // potentially existing references.
+        const references = [...(prevMessage.references ?? [])];
+        message.references.forEach(ref => {
+          if (!references.some(cur => cur.path === ref.path)) {
+            references.push(ref);
+          }
+        });
+        message = {
+          ...message,
+          references
+        };
+
+        // Description: In case we have conflicting descriptions, the new one wins.
+        if (prevMessage.description && !message.description) {
+          message = {
+            ...message,
+            description: prevMessage.description
+          };
+        }
+      }
+      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);
+    }
+
+    // Don't delete IDs still used in other files
+    const relativeFilePath = path.relative(this.projectRoot, absoluteFilePath);
+    const idsToDelete = idsToRemove.filter(id => {
+      const message = this.messagesById.get(id);
+      return !message?.references?.some(ref => ref.path !== relativeFilePath);
+    });
+
+    // Clean up removed messages from `messagesById`
+    idsToDelete.forEach(id => {
+      this.messagesById.delete(id);
+    });
+
+    // Update the stored messages
+    const hasMessages = result.messages.length > 0;
+    if (hasMessages) {
+      this.messagesByFile.set(absoluteFilePath, fileMessages);
+    } else {
+      this.messagesByFile.delete(absoluteFilePath);
+    }
+    const changed = this.haveMessagesChanged(prevFileMessages, fileMessages);
+    return {
+      ...result,
+      changed
+    };
+  }
+  haveMessagesChanged(beforeMessages, afterMessages) {
+    // If one exists and the other doesn't, there's a change
+    if (!beforeMessages) {
+      return afterMessages.size > 0;
+    }
+
+    // Different sizes means changes
+    if (beforeMessages.size !== afterMessages.size) {
+      return true;
+    }
+
+    // Check differences in beforeMessages vs afterMessages
+    for (const [id, msg1] of beforeMessages) {
+      const msg2 = afterMessages.get(id);
+      if (!msg2 || !this.areMessagesEqual(msg1, msg2)) {
+        return true; // Early exit on first difference
+      }
+    }
+    return false;
+  }
+  areMessagesEqual(msg1, msg2) {
+    return msg1.id === msg2.id && msg1.message === msg2.message && msg1.description === msg2.description && this.areReferencesEqual(msg1.references, msg2.references);
+  }
+  areReferencesEqual(refs1, refs2) {
+    // Both undefined or both empty
+    if (!refs1 && !refs2) return true;
+    if (!refs1 || !refs2) return false;
+    if (refs1.length !== refs2.length) return false;
+
+    // Compare each reference
+    for (let i = 0; i < refs1.length; i++) {
+      if (refs1[i].path !== refs2[i].path) {
+        return false;
+      }
+    }
+    return true;
+  }
+  async save() {
+    return this.saveScheduler.schedule(() => this.saveImpl());
+  }
+  async saveImpl() {
+    const messages = Array.from(this.messagesById.values());
+    const persister = await this.getPersister();
+    await persister.write(this.config.sourceLocale, messages);
+    for (const locale of await this.getTargetLocales()) {
+      await this.saveLocale(locale);
+    }
+    return messages.length;
+  }
+  async saveLocale(locale) {
+    const messages = Array.from(this.messagesById.values());
+    const persister = await this.getPersister();
+
+    // Check if file was modified externally
+    const lastWriteTime = this.lastWriteByLocale.get(locale);
+    const currentFileTime = await persister.getLastModified(locale);
+
+    // If file was modified externally, read and merge
+    if (currentFileTime && lastWriteTime && currentFileTime > lastWriteTime) {
+      const diskMessages = await persister.read(locale);
+      const translations = this.translationsByTargetLocale.get(locale);
+      for (const diskMessage of diskMessages) {
+        // Disk wins: preserve manual edits
+        translations.set(diskMessage.id, diskMessage.message);
+      }
+    }
+    const translations = this.translationsByTargetLocale.get(locale);
+    const localeMessages = messages.map(message => ({
+      ...message,
+      message: translations.get(message.id) || ''
+    }));
+    await persister.write(locale, localeMessages);
+
+    // Update timestamps
+    const newTime = await persister.getLastModified(locale);
+    this.lastWriteByLocale.set(locale, newTime);
+  }
+  onLocalesChange = async params => {
+    for (const locale of params.added) {
+      const translations = new Map();
+      this.translationsByTargetLocale.set(locale, translations);
+      const messages = await this.loadLocaleMessages(locale);
+      for (const message of messages) {
+        translations.set(message.id, message.message);
+      }
+      await this.saveLocale(locale);
+    }
+    for (const locale of params.removed) {
+      this.translationsByTargetLocale.delete(locale);
+      this.lastWriteByLocale.delete(locale);
+    }
+  };
+  destroy() {
+    this.saveScheduler.destroy();
+    if (this.catalogLocales && this.isDevelopment) {
+      this.catalogLocales.unsubscribeLocalesChange(this.onLocalesChange);
+    }
+  }
+}
+
+export { CatalogManager as default };

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

@@ -0,0 +1,45 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+class CatalogPersister {
+  constructor(messagesPath, formatter) {
+    this.messagesPath = messagesPath;
+    this.formatter = formatter;
+  }
+  getFilePath(locale) {
+    return path.join(this.messagesPath, locale + this.formatter.EXTENSION);
+  }
+  async read(locale) {
+    const filePath = this.getFilePath(locale);
+    const content = await fs.readFile(filePath, 'utf8');
+    return this.formatter.parse(content, {
+      locale
+    });
+  }
+  async write(locale, messages) {
+    const filePath = this.getFilePath(locale);
+    const content = this.formatter.serialize(messages, {
+      locale
+    });
+    try {
+      const outputDir = path.dirname(filePath);
+      await fs.mkdir(outputDir, {
+        recursive: true
+      });
+      await fs.writeFile(filePath, content);
+    } catch (error) {
+      console.error(`❌ Failed to write catalog: ${error}`);
+    }
+  }
+  async getLastModified(locale) {
+    const filePath = this.getFilePath(locale);
+    try {
+      const stats = await fs.stat(filePath);
+      return stats.mtime;
+    } catch {
+      return undefined;
+    }
+  }
+}
+
+export { CatalogPersister as default };