@depup/next-intl 4.8.3-depup.0

package/dist/cjs/development/plugin.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var plugin = require('./plugin-YzBhQjAo.cjs');
+require('fs/promises');
+require('path');
+require('@parcel/watcher');
+require('fs');
+require('module');
+require('@swc/core');
+
+
+
+module.exports = plugin.createNextIntlPlugin;

package/dist/esm/development/config.js

@@ -0,0 +1,5 @@
+function getConfig() {
+  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 { getConfig as default };

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

@@ -0,0 +1,38 @@
+import CatalogManager from './catalog/CatalogManager.js';
+import MessageExtractor from './extractor/MessageExtractor.js';
+
+class ExtractionCompiler {
+  constructor(config, opts = {}) {
+    const extractor = opts.extractor ?? new MessageExtractor(opts);
+    this.manager = new CatalogManager(config, {
+      ...opts,
+      extractor
+    });
+    this[Symbol.dispose] = this[Symbol.dispose].bind(this);
+    this.installExitHandlers();
+  }
+  async extractAll() {
+    // 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();
+  }
+  [Symbol.dispose]() {
+    this.uninstallExitHandlers();
+    this.manager[Symbol.dispose]();
+  }
+  installExitHandlers() {
+    const cleanup = this[Symbol.dispose];
+    process.on('exit', cleanup);
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+  }
+  uninstallExitHandlers() {
+    const cleanup = this[Symbol.dispose];
+    process.off('exit', cleanup);
+    process.off('SIGINT', cleanup);
+    process.off('SIGTERM', cleanup);
+  }
+}
+
+export { ExtractionCompiler as default };

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

@@ -0,0 +1,84 @@
+import fs$1 from 'fs';
+import fs from 'fs/promises';
+import path from 'path';
+
+class CatalogLocales {
+  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();
+      }
+    });
+  }
+  stopWatcher() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = undefined;
+    }
+  }
+  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
+        });
+      }
+    }
+  }
+}
+
+export { CatalogLocales as default };

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

@@ -0,0 +1,370 @@
+import fs from 'fs/promises';
+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 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.
+   */
+  messagesByFile = 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.
+   */
+  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
+
+  // Resolves when all catalogs are loaded
+
+  // Resolves when the initial project scan and processing is complete
+
+  constructor(config, opts) {
+    this.config = config;
+    this.saveScheduler = new SaveScheduler(50);
+    this.projectRoot = opts.projectRoot ?? getDefaultProjectRoot();
+    this.isDevelopment = opts.isDevelopment ?? false;
+    this.extractor = opts.extractor;
+    if (this.isDevelopment) {
+      // We kick this off as early as possible, so we get notified about changes
+      // that happen during the initial project scan (while awaiting it to
+      // complete though)
+      this.sourceWatcher = new SourceFileWatcher(this.getSrcPaths(), this.handleFileEvents.bind(this));
+      void this.sourceWatcher.start();
+    }
+  }
+  async getCodec() {
+    if (!this.codec) {
+      this.codec = await resolveCodec(this.config.messages.format, this.projectRoot);
+    }
+    return this.codec;
+  }
+  async getPersister() {
+    if (this.persister) {
+      return this.persister;
+    } else {
+      this.persister = new CatalogPersister({
+        messagesPath: this.config.messages.path,
+        codec: await this.getCodec(),
+        extension: getFormatExtension(this.config.messages.format)
+      });
+      return this.persister;
+    }
+  }
+  getCatalogLocales() {
+    if (this.catalogLocales) {
+      return this.catalogLocales;
+    } else {
+      const messagesDir = path.join(this.projectRoot, this.config.messages.path);
+      this.catalogLocales = new CatalogLocales({
+        messagesDir,
+        sourceLocale: this.config.sourceLocale,
+        extension: getFormatExtension(this.config.messages.format),
+        locales: this.config.messages.locales
+      });
+      return this.catalogLocales;
+    }
+  }
+  async getTargetLocales() {
+    return this.getCatalogLocales().getTargetLocales();
+  }
+  getSrcPaths() {
+    return (Array.isArray(this.config.srcPath) ? this.config.srcPath : [this.config.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)));
+      this.mergeSourceDiskMetadata(sourceDiskMessages);
+    })();
+    await this.scanCompletePromise;
+    if (this.isDevelopment) {
+      const catalogLocales = this.getCatalogLocales();
+      catalogLocales.subscribeLocalesChange(this.onLocalesChange);
+    }
+  }
+  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 byId = new Map();
+    for (const diskMessage of diskMessages) {
+      byId.set(diskMessage.id, diskMessage);
+    }
+    return byId;
+  }
+  async loadLocaleMessages(locale) {
+    const persister = await this.getPersister();
+    const messages = await persister.read(locale);
+    const fileTime = await persister.getLastModified(locale);
+    this.lastWriteByLocale.set(locale, fileTime);
+    return messages;
+  }
+  async loadTargetMessages() {
+    const targetLocales = await this.getTargetLocales();
+    await Promise.all(targetLocales.map(locale => this.reloadLocaleCatalog(locale)));
+  }
+  async reloadLocaleCatalog(locale) {
+    const diskMessages = await this.loadLocaleMessages(locale);
+    if (locale === this.config.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)) {
+              // For unknown properties (like flags), disk wins
+              prev[key] = diskMessage[key];
+            }
+          }
+        }
+      }
+    } else {
+      // For target: disk wins completely, BUT preserve existing translations
+      // if we read empty (likely a write in progress by an external tool
+      // that causes the file to temporarily be empty)
+      const existingTranslations = this.translationsByTargetLocale.get(locale);
+      const hasExistingTranslations = existingTranslations && existingTranslations.size > 0;
+      if (diskMessages.length > 0) {
+        // We got content from disk, replace with it
+        const translations = new Map();
+        for (const message of diskMessages) {
+          translations.set(message.id, message);
+        }
+        this.translationsByTargetLocale.set(locale, translations);
+      } else if (hasExistingTranslations) ; else {
+        // We read empty and have no existing translations
+        const translations = new Map();
+        this.translationsByTargetLocale.set(locale, translations);
+      }
+    }
+  }
+  mergeSourceDiskMetadata(diskMessages) {
+    for (const [id, diskMessage] of diskMessages) {
+      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.
+      for (const key of Object.keys(diskMessage)) {
+        if (existing[key] == null) {
+          existing[key] = diskMessage[key];
+        }
+      }
+    }
+  }
+  async processFile(absoluteFilePath) {
+    let messages = [];
+    try {
+      const content = await fs.readFile(absoluteFilePath, 'utf8');
+      let extraction;
+      try {
+        extraction = await this.extractor.extract(absoluteFilePath, content);
+      } catch {
+        return false;
+      }
+      messages = extraction.messages;
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        throw err;
+      }
+      // 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);
+
+      // Merge with previous message if it exists
+      if (prevMessage) {
+        message = {
+          ...message
+        };
+        if (message.references) {
+          message.references = this.mergeReferences(prevMessage.references ?? [], relativeFilePath, message.references);
+        }
+
+        // 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];
+          }
+        }
+      }
+      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);
+    }
+
+    // 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);
+      } 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);
+      }
+    });
+
+    // 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;
+  }
+  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);
+  }
+  haveMessagesChangedForFile(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) {
+    // 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;
+  }
+  async save() {
+    return this.saveScheduler.schedule(() => this.saveImpl());
+  }
+  async saveImpl() {
+    await this.saveLocale(this.config.sourceLocale);
+    const targetLocales = await this.getTargetLocales();
+    await Promise.all(targetLocales.map(locale => this.saveLocale(locale)));
+  }
+  async saveLocale(locale) {
+    await this.loadCatalogsPromise;
+    const messages = Array.from(this.messagesById.values());
+    const persister = await this.getPersister();
+    const isSourceLocale = locale === this.config.sourceLocale;
+
+    // Check if file was modified externally (poll-at-save is cheaper than
+    // watchers here since stat() is fast and avoids continuous overhead)
+    const lastWriteTime = this.lastWriteByLocale.get(locale);
+    const currentFileTime = await persister.getLastModified(locale);
+    if (currentFileTime && lastWriteTime && currentFileTime > lastWriteTime) {
+      await this.reloadLocaleCatalog(locale);
+    }
+    const localeMessages = isSourceLocale ? this.messagesById : this.translationsByTargetLocale.get(locale);
+    const messagesToPersist = messages.map(message => {
+      const localeMessage = localeMessages?.get(message.id);
+      return {
+        ...localeMessage,
+        id: message.id,
+        description: message.description,
+        references: message.references,
+        message: isSourceLocale ? message.message : localeMessage?.message ?? ''
+      };
+    });
+    await persister.write(messagesToPersist, {
+      locale,
+      sourceMessagesById: this.messagesById
+    });
+
+    // Update timestamps
+    const newTime = await persister.getLastModified(locale);
+    this.lastWriteByLocale.set(locale, newTime);
+  }
+  onLocalesChange = async params => {
+    // Chain to existing promise
+    this.loadCatalogsPromise = Promise.all([this.loadCatalogsPromise, ...params.added.map(locale => this.reloadLocaleCatalog(locale))]);
+    for (const locale of params.added) {
+      await this.saveLocale(locale);
+    }
+    for (const locale of params.removed) {
+      this.translationsByTargetLocale.delete(locale);
+      this.lastWriteByLocale.delete(locale);
+    }
+  };
+  async handleFileEvents(events) {
+    if (this.loadCatalogsPromise) {
+      await this.loadCatalogsPromise;
+    }
+
+    // Wait for initial scan to complete to avoid race conditions
+    if (this.scanCompletePromise) {
+      await this.scanCompletePromise;
+    }
+    let changed = false;
+    const expandedEvents = await this.sourceWatcher.expandDirectoryDeleteEvents(events, Array.from(this.messagesByFile.keys()));
+    for (const event of expandedEvents) {
+      const hasChanged = await this.processFile(event.path);
+      changed ||= hasChanged;
+    }
+    if (changed) {
+      await this.save();
+    }
+  }
+  [Symbol.dispose]() {
+    this.sourceWatcher?.stop();
+    this.sourceWatcher = undefined;
+    this.saveScheduler[Symbol.dispose]();
+    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,63 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+class CatalogPersister {
+  constructor(params) {
+    this.messagesPath = params.messagesPath;
+    this.codec = params.codec;
+    this.extension = params.extension;
+  }
+  getFileName(locale) {
+    return locale + this.extension;
+  }
+  getFilePath(locale) {
+    return path.join(this.messagesPath, this.getFileName(locale));
+  }
+  async read(locale) {
+    const filePath = this.getFilePath(locale);
+    let content;
+    try {
+      content = await fs.readFile(filePath, 'utf8');
+    } catch (error) {
+      if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+        return [];
+      }
+      throw new Error(`Error while reading ${this.getFileName(locale)}:\n> ${error}`, {
+        cause: error
+      });
+    }
+    try {
+      return this.codec.decode(content, {
+        locale
+      });
+    } catch (error) {
+      throw new Error(`Error while decoding ${this.getFileName(locale)}:\n> ${error}`, {
+        cause: error
+      });
+    }
+  }
+  async write(messages, context) {
+    const filePath = this.getFilePath(context.locale);
+    const content = this.codec.encode(messages, context);
+    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 };

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

@@ -0,0 +1,85 @@
+/**
+ * De-duplicates excessive save invocations,
+ * while keeping a single one instant.
+ */
+class SaveScheduler {
+  isSaving = false;
+  pendingResolvers = [];
+  constructor(delayMs = 50) {
+    this.delayMs = delayMs;
+  }
+  async schedule(saveTask) {
+    return new Promise((resolve, reject) => {
+      this.pendingResolvers.push({
+        resolve,
+        reject
+      });
+      this.nextSaveTask = saveTask;
+      if (!this.isSaving && !this.saveTimeout) {
+        // Not currently saving and no scheduled save, save immediately
+        this.executeSave();
+      } else if (this.saveTimeout) {
+        // A save is already scheduled, reschedule to debounce
+        this.scheduleSave();
+      }
+      // If isSaving is true and no timeout is scheduled, the current save
+      // will check for pending resolvers when it completes and schedule
+      // another save if needed (see finally block in executeSave)
+    });
+  }
+  scheduleSave() {
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout);
+    }
+    this.saveTimeout = setTimeout(() => {
+      this.saveTimeout = undefined;
+      this.executeSave();
+    }, this.delayMs);
+  }
+  async executeSave() {
+    if (this.isSaving) {
+      return;
+    }
+    const saveTask = this.nextSaveTask;
+    if (!saveTask) {
+      return;
+    }
+
+    // Capture current pending resolvers for this save
+    const resolversForThisSave = this.pendingResolvers;
+    this.pendingResolvers = [];
+    this.nextSaveTask = undefined;
+    this.isSaving = true;
+    try {
+      const result = await saveTask();
+
+      // Resolve only the promises that were pending when this save started
+      resolversForThisSave.forEach(({
+        resolve
+      }) => resolve(result));
+    } catch (error) {
+      // Reject only the promises that were pending when this save started
+      resolversForThisSave.forEach(({
+        reject
+      }) => reject(error));
+    } finally {
+      this.isSaving = false;
+
+      // If new saves were requested during this save, schedule another
+      if (this.pendingResolvers.length > 0) {
+        this.scheduleSave();
+      }
+    }
+  }
+  [Symbol.dispose]() {
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout);
+      this.saveTimeout = undefined;
+    }
+    this.pendingResolvers = [];
+    this.nextSaveTask = undefined;
+    this.isSaving = false;
+  }
+}
+
+export { SaveScheduler as default };