@depup/next-intl 4.8.3-depup.0

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

@@ -0,0 +1,96 @@
+import path from 'path';
+import compile from 'icu-minify/compile';
+import { getFormatExtension, resolveCodec } from './format/index.js';
+import { setNestedProperty } from './utils.js';
+
+// The module scope is safe for some caching, but Next.js can
+// create multiple loader instances so don't expect a singleton.
+let cachedCodec = null;
+const messageCacheByCatalog = new Map();
+function getMessageCache(catalogId) {
+  let cache = messageCacheByCatalog.get(catalogId);
+  if (!cache) {
+    cache = new Map();
+    messageCacheByCatalog.set(catalogId, cache);
+  }
+  return cache;
+}
+async function getCodec(options, projectRoot) {
+  if (!cachedCodec) {
+    cachedCodec = await resolveCodec(options.messages.format, projectRoot);
+  }
+  return cachedCodec;
+}
+
+/**
+ * Parses and optimizes catalog files.
+ *
+ * Note that if we use a dynamic import like `import(`${locale}.json`)`, then
+ * the loader will optimistically run for all candidates in this folder (both
+ * during dev as well as at build time).
+ */
+function catalogLoader(source) {
+  const options = this.getOptions();
+  const callback = this.async();
+  const extension = getFormatExtension(options.messages.format);
+  getCodec(options, this.rootContext).then(codec => {
+    const locale = path.basename(this.resourcePath, extension);
+    let outputString;
+    if (options.messages.precompile) {
+      const decoded = codec.decode(source, {
+        locale
+      });
+      const cache = getMessageCache(this.resourcePath);
+      const precompiled = precompileMessages(decoded, cache);
+      outputString = JSON.stringify(precompiled);
+    } else {
+      outputString = codec.toJSONString(source, {
+        locale
+      });
+    }
+
+    // https://v8.dev/blog/cost-of-javascript-2019#json
+    const result = `export default JSON.parse(${JSON.stringify(outputString)});`;
+    callback(null, result);
+  }).catch(callback);
+}
+
+/**
+ * Recursively precompiles all ICU message strings in a messages object
+ * using icu-minify/compile for smaller runtime bundles.
+ */
+function precompileMessages(messages, cache) {
+  const result = {};
+  const cacheKeysToEvict = new Set(cache.keys());
+  for (const message of messages) {
+    cacheKeysToEvict.delete(message.id);
+    const messageValue = message.message;
+    if (Array.isArray(messageValue)) {
+      throw new Error(`Message at \`${message.id}\` resolved to an array, but only strings are supported. See https://next-intl.dev/docs/usage/translations#arrays-of-messages`);
+    }
+    if (typeof messageValue === 'object') {
+      throw new Error(`Message at \`${message.id}\` resolved to \`${typeof messageValue}\`, but only strings are supported. Use a \`.\` to retrieve nested messages. See https://next-intl.dev/docs/usage/translations#structuring-messages`);
+    }
+    const cachedEntry = cache.get(message.id);
+    const hasCacheMatch = cachedEntry?.messageValue === messageValue;
+    let compiledMessage;
+    if (hasCacheMatch) {
+      compiledMessage = cachedEntry.compiledMessage;
+    } else {
+      compiledMessage = compile(messageValue);
+      cache.set(message.id, {
+        compiledMessage,
+        messageValue
+      });
+    }
+    setNestedProperty(result, message.id, compiledMessage);
+  }
+
+  // Evict unused cache entries
+  for (const cachedId of cacheKeysToEvict) {
+    cache.delete(cachedId);
+  }
+  return result;
+}
+
+export { catalogLoader as default };

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

@@ -0,0 +1,15 @@
+import ExtractionCompiler from './ExtractionCompiler.js';
+import MessageExtractor from './extractor/MessageExtractor.js';
+import { getDefaultProjectRoot } from './utils.js';
+
+async function extractMessages(params) {
+  const compiler = new ExtractionCompiler(params, {
+    extractor: new MessageExtractor({
+      isDevelopment: false,
+      projectRoot: getDefaultProjectRoot()
+    })
+  });
+  await compiler.extractAll();
+}
+
+export { extractMessages as default };

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

@@ -0,0 +1,26 @@
+import MessageExtractor from './extractor/MessageExtractor.js';
+
+// Module-level extractor instance for transformation caching.
+// Note: Next.js/Turbopack may create multiple loader instances, but each
+// only handles file transformation. The ExtractionCompiler (which manages
+// catalogs) is initialized separately in createNextIntlPlugin.
+let extractor;
+function extractionLoader(source) {
+  const callback = this.async();
+  const projectRoot = this.rootContext;
+
+  // Avoid rollup's `replace` plugin to compile this away
+  const isDevelopment = process.env['NODE_ENV'.trim()] === 'development';
+  if (!extractor) {
+    extractor = new MessageExtractor({
+      isDevelopment,
+      projectRoot,
+      sourceMap: this.sourceMap
+    });
+  }
+  extractor.extract(this.resourcePath, source).then(result => {
+    callback(null, result.code, result.map);
+  }).catch(callback);
+}
+
+export { extractionLoader as default };

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

@@ -0,0 +1,30 @@
+class LRUCache {
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+    this.cache = new Map();
+  }
+  set(key, value) {
+    const isNewKey = !this.cache.has(key);
+    if (isNewKey && this.cache.size >= this.maxSize) {
+      const lruKey = this.cache.keys().next().value;
+      if (lruKey !== undefined) {
+        this.cache.delete(lruKey);
+      }
+    }
+    this.cache.set(key, {
+      key,
+      value
+    });
+  }
+  get(key) {
+    const item = this.cache.get(key);
+    if (item) {
+      this.cache.delete(key);
+      this.cache.set(key, item);
+      return item.value;
+    }
+    return undefined;
+  }
+}
+
+export { LRUCache as default };

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

@@ -0,0 +1,66 @@
+import { createRequire } from 'module';
+import path from 'path';
+import { transform } from '@swc/core';
+import { getDefaultProjectRoot, normalizePathToPosix } from '../utils.js';
+import LRUCache from './LRUCache.js';
+
+const require$1 = createRequire(import.meta.url);
+class MessageExtractor {
+  compileCache = new LRUCache(750);
+  constructor(opts) {
+    this.isDevelopment = opts.isDevelopment ?? false;
+    this.projectRoot = opts.projectRoot ?? getDefaultProjectRoot();
+    this.sourceMap = opts.sourceMap ?? false;
+  }
+  async extract(absoluteFilePath, source) {
+    const cacheKey = [source, absoluteFilePath].join('!');
+    const cached = this.compileCache.get(cacheKey);
+    if (cached) return cached;
+
+    // Shortcut parsing if hook is not used. The Turbopack integration already
+    // pre-filters this, but for webpack this feature doesn't exist, so we need
+    // to do it here.
+    if (!source.includes('useExtracted') && !source.includes('getExtracted')) {
+      return {
+        messages: [],
+        code: source
+      };
+    }
+    const filePath = normalizePathToPosix(path.relative(this.projectRoot, absoluteFilePath));
+    const result = await transform(source, {
+      jsc: {
+        target: 'esnext',
+        parser: {
+          syntax: 'typescript',
+          tsx: true,
+          decorators: true
+        },
+        experimental: {
+          cacheRoot: 'node_modules/.cache/swc',
+          disableBuiltinTransformsForInternalTesting: true,
+          disableAllLints: true,
+          plugins: [[require$1.resolve('next-intl-swc-plugin-extractor'), {
+            isDevelopment: this.isDevelopment,
+            filePath
+          }]]
+        }
+      },
+      sourceMaps: this.sourceMap,
+      sourceFileName: filePath,
+      filename: filePath
+    });
+
+    // TODO: Improve the typing of @swc/core
+    const output = result.output;
+    const messages = JSON.parse(JSON.parse(output).results);
+    const extractionResult = {
+      code: result.code,
+      map: result.map,
+      messages
+    };
+    this.compileCache.set(cacheKey, extractionResult);
+    return extractionResult;
+  }
+}
+
+export { MessageExtractor as default };

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

@@ -0,0 +1,5 @@
+function defineCodec(factory) {
+  return factory;
+}
+
+export { defineCodec };

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

@@ -0,0 +1,42 @@
+import { getSortedMessages, setNestedProperty } from '../../utils.js';
+import { defineCodec } from '../ExtractorCodec.js';
+
+var JSONCodec = defineCodec(() => ({
+  decode(source) {
+    const json = JSON.parse(source);
+    const messages = [];
+    traverseMessages(json, (message, id) => {
+      messages.push({
+        id,
+        message
+      });
+    });
+    return messages;
+  },
+  encode(messages) {
+    const root = {};
+    for (const message of getSortedMessages(messages)) {
+      setNestedProperty(root, message.id, message.message);
+    }
+    return JSON.stringify(root, null, 2) + '\n';
+  },
+  toJSONString(source) {
+    return source;
+  }
+}));
+function traverseMessages(obj, callback, path = '') {
+  const NAMESPACE_SEPARATOR = '.';
+  for (const key of Object.keys(obj)) {
+    const newPath = path ? path + NAMESPACE_SEPARATOR + key : key;
+    const value = obj[key];
+    if (typeof value === 'string') {
+      callback(value, newPath);
+    } else if (Array.isArray(value)) {
+      throw new Error(`Message at \`${newPath}\` resolved to an array, but only strings are supported. See https://next-intl.dev/docs/usage/translations#arrays-of-messages`);
+    } else if (typeof value === 'object') {
+      traverseMessages(value, callback, newPath);
+    }
+  }
+}
+
+export { JSONCodec as default };

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

@@ -0,0 +1,93 @@
+import POParser from 'po-parser';
+import { setNestedProperty, getSortedMessages } from '../../utils.js';
+import { defineCodec } from '../ExtractorCodec.js';
+
+var POCodec = defineCodec(() => {
+  // See also https://www.gnu.org/software/gettext/manual/html_node/Header-Entry.html
+  const 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'
+  };
+
+  // Move all parts before the last dot to msgctxt
+  const NAMESPACE_SEPARATOR = '.';
+
+  // Metadata is stored so it can be retained when writing
+  const metadataByLocale = new Map();
+  return {
+    decode(content, context) {
+      const catalog = POParser.parse(content);
+      if (catalog.meta) {
+        metadataByLocale.set(context.locale, catalog.meta);
+      }
+      const messages = catalog.messages || [];
+      return messages.map(msg => {
+        const {
+          extractedComments,
+          msgctxt,
+          msgid,
+          msgstr,
+          ...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]
+          })
+        };
+      });
+    },
+    encode(messages, context) {
+      const encodedMessages = getSortedMessages(messages).map(msg => {
+        const {
+          description,
+          id,
+          message,
+          ...rest
+        } = msg;
+        const lastDotIndex = id.lastIndexOf(NAMESPACE_SEPARATOR);
+        const hasNamespace = id.includes(NAMESPACE_SEPARATOR);
+        const msgid = hasNamespace ? id.slice(lastDotIndex + NAMESPACE_SEPARATOR.length) : id;
+        return {
+          msgid,
+          msgstr: message,
+          ...(description && {
+            extractedComments: [description]
+          }),
+          ...(hasNamespace && {
+            msgctxt: id.slice(0, lastDotIndex)
+          }),
+          ...rest
+        };
+      });
+      return POParser.serialize({
+        meta: {
+          Language: context.locale,
+          ...DEFAULT_METADATA,
+          ...metadataByLocale.get(context.locale)
+        },
+        messages: encodedMessages
+      });
+    },
+    toJSONString(source, context) {
+      const parsed = this.decode(source, context);
+      const messagesObject = {};
+      for (const message of parsed) {
+        setNestedProperty(messagesObject, message.id, message.message);
+      }
+      return JSON.stringify(messagesObject);
+    }
+  };
+});
+
+export { POCodec as default };

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

@@ -0,0 +1,44 @@
+import path from 'path';
+import { throwError } from '../../plugin/utils.js';
+
+const formats = {
+  json: {
+    codec: () => import('./codecs/JSONCodec.js'),
+    extension: '.json'
+  },
+  po: {
+    codec: () => import('./codecs/POCodec.js'),
+    extension: '.po'
+  }
+};
+function isBuiltInFormat(format) {
+  return typeof format === 'string' && format in formats;
+}
+function getFormatExtension(format) {
+  if (isBuiltInFormat(format)) {
+    return formats[format].extension;
+  } else {
+    return format.extension;
+  }
+}
+async function resolveCodec(format, projectRoot) {
+  if (isBuiltInFormat(format)) {
+    const factory = (await formats[format].codec()).default;
+    return factory();
+  } else {
+    const resolvedPath = path.isAbsolute(format.codec) ? format.codec : path.resolve(projectRoot, format.codec);
+    let module;
+    try {
+      module = await import(resolvedPath);
+    } catch (error) {
+      throwError(`Could not load codec from "${resolvedPath}".\n${error}`);
+    }
+    const factory = module.default;
+    if (!factory || typeof factory !== 'function') {
+      throwError(`Codec at "${resolvedPath}" must have a default export returned from \`defineCodec\`.`);
+    }
+    return factory();
+  }
+}
+
+export { formats as default, getFormatExtension, resolveCodec };

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

@@ -0,0 +1,29 @@
+import path from 'path';
+
+class SourceFileFilter {
+  static EXTENSIONS = ['ts', 'tsx', 'js', 'jsx'];
+
+  // Will not be entered, except if explicitly asked for
+  // TODO: At some point we should infer these from .gitignore
+  static IGNORED_DIRECTORIES = ['node_modules', '.next', '.git'];
+  static isSourceFile(filePath) {
+    const ext = path.extname(filePath);
+    return SourceFileFilter.EXTENSIONS.map(cur => '.' + cur).includes(ext);
+  }
+  static shouldEnterDirectory(dirPath, srcPaths) {
+    const dirName = path.basename(dirPath);
+    if (SourceFileFilter.IGNORED_DIRECTORIES.includes(dirName)) {
+      return SourceFileFilter.isIgnoredDirectoryExplicitlyIncluded(dirPath, srcPaths);
+    }
+    return true;
+  }
+  static isIgnoredDirectoryExplicitlyIncluded(ignoredDirPath, srcPaths) {
+    return srcPaths.some(srcPath => SourceFileFilter.isWithinPath(srcPath, ignoredDirPath));
+  }
+  static isWithinPath(targetPath, basePath) {
+    const relativePath = path.relative(basePath, targetPath);
+    return relativePath === '' || !relativePath.startsWith('..');
+  }
+}
+
+export { SourceFileFilter as default };

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

@@ -0,0 +1,31 @@
+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()) {
+        if (!SourceFileFilter.shouldEnterDirectory(entryPath, srcPaths)) {
+          continue;
+        }
+        await SourceFileScanner.walkSourceFiles(entryPath, srcPaths, acc);
+      } else {
+        if (SourceFileFilter.isSourceFile(entry.name)) {
+          acc.push(entryPath);
+        }
+      }
+    }
+    return acc;
+  }
+  static async getSourceFiles(srcPaths) {
+    const files = (await Promise.all(srcPaths.map(srcPath => SourceFileScanner.walkSourceFiles(srcPath, srcPaths)))).flat();
+    return new Set(files);
+  }
+}
+
+export { SourceFileScanner as default };

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

@@ -0,0 +1,132 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { subscribe } from '@parcel/watcher';
+import SourceFileFilter from './SourceFileFilter.js';
+import SourceFileScanner from './SourceFileScanner.js';
+
+class SourceFileWatcher {
+  subscriptions = [];
+  constructor(roots, onChange) {
+    this.roots = roots;
+    this.onChange = onChange;
+  }
+  async start() {
+    if (this.subscriptions.length > 0) {
+      return;
+    }
+    const ignore = SourceFileFilter.IGNORED_DIRECTORIES.map(dir => `**/${dir}/**`);
+    for (const root of this.roots) {
+      const sub = await subscribe(root, async (err, events) => {
+        if (err) {
+          console.error(err);
+          return;
+        }
+        const filtered = await this.normalizeEvents(events);
+        if (filtered.length > 0) {
+          void this.onChange(filtered);
+        }
+      }, {
+        ignore
+      });
+      this.subscriptions.push(sub);
+    }
+  }
+  async normalizeEvents(events) {
+    const directoryCreatePaths = [];
+    const otherEvents = [];
+
+    // We need to expand directory creates because during rename operations,
+    // @parcel/watcher emits a directory create event but may not emit individual
+    // file events for the moved files
+    await Promise.all(events.map(async event => {
+      if (event.type === 'create') {
+        try {
+          const stats = await fs.stat(event.path);
+          if (stats.isDirectory()) {
+            directoryCreatePaths.push(event.path);
+            return;
+          }
+        } catch {
+          // Path doesn't exist or is inaccessible, treat as file
+        }
+      }
+      otherEvents.push(event);
+    }));
+
+    // Expand directory create events to find source files inside
+    let expandedCreateEvents = [];
+    if (directoryCreatePaths.length > 0) {
+      try {
+        const sourceFiles = await SourceFileScanner.getSourceFiles(directoryCreatePaths);
+        expandedCreateEvents = Array.from(sourceFiles).map(filePath => ({
+          type: 'create',
+          path: filePath
+        }));
+      } catch {
+        // Directories might have been deleted or are inaccessible
+      }
+    }
+
+    // Combine original events with expanded directory creates.
+    // Deduplicate by path to avoid processing the same file twice
+    // in case @parcel/watcher also emitted individual file events.
+    const allEvents = [...otherEvents, ...expandedCreateEvents];
+    const seenPaths = new Set();
+    const deduplicated = [];
+    for (const event of allEvents) {
+      const key = `${event.type}:${event.path}`;
+      if (!seenPaths.has(key)) {
+        seenPaths.add(key);
+        deduplicated.push(event);
+      }
+    }
+    return deduplicated.filter(event => {
+      // Keep all delete events (might be deleted directories that no longer exist)
+      if (event.type === 'delete') {
+        return true;
+      }
+      // Keep source files
+      return SourceFileFilter.isSourceFile(event.path);
+    });
+  }
+  async expandDirectoryDeleteEvents(events, prevKnownFiles) {
+    const expanded = [];
+    for (const event of events) {
+      if (event.type === 'delete' && !SourceFileFilter.isSourceFile(event.path)) {
+        const dirPath = path.resolve(event.path);
+        const filesInDirectory = [];
+        for (const filePath of prevKnownFiles) {
+          if (SourceFileFilter.isWithinPath(filePath, dirPath)) {
+            filesInDirectory.push(filePath);
+          }
+        }
+
+        // If we found files within this path, it was a directory
+        if (filesInDirectory.length > 0) {
+          for (const filePath of filesInDirectory) {
+            expanded.push({
+              type: 'delete',
+              path: filePath
+            });
+          }
+        } else {
+          // Not a directory or no files in it, pass through as-is
+          expanded.push(event);
+        }
+      } else {
+        // Pass through as-is
+        expanded.push(event);
+      }
+    }
+    return expanded;
+  }
+  async stop() {
+    await Promise.all(this.subscriptions.map(sub => sub.unsubscribe()));
+    this.subscriptions = [];
+  }
+  [Symbol.dispose]() {
+    void this.stop();
+  }
+}
+
+export { SourceFileWatcher as default };

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

@@ -0,0 +1,46 @@
+import path from 'path';
+
+function normalizePathToPosix(filePath) {
+  // `path.relative` uses OS-specific separators. For stable `.po` references we
+  // always use POSIX separators, regardless of the OS that ran extraction.
+  return path.posix.normalize(filePath.split(path.win32.sep).join(path.posix.sep));
+}
+
+// Essentialls lodash/set, but we avoid this dependency
+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;
+}
+function getSortedMessages(messages) {
+  return messages.toSorted((messageA, messageB) => {
+    const refA = messageA.references?.[0];
+    const refB = messageB.references?.[0];
+
+    // No references: preserve original (extraction) order
+    if (!refA || !refB) return 0;
+
+    // Sort by path, then line. Same path+line: preserve original order
+    return compareReferences(refA, refB);
+  });
+}
+function localeCompare(a, b) {
+  return a.localeCompare(b, 'en');
+}
+function compareReferences(refA, refB) {
+  const pathCompare = localeCompare(refA.path, refB.path);
+  if (pathCompare !== 0) return pathCompare;
+  return (refA.line ?? 0) - (refB.line ?? 0);
+}
+function getDefaultProjectRoot() {
+  return process.cwd();
+}
+
+export { compareReferences, getDefaultProjectRoot, getSortedMessages, localeCompare, normalizePathToPosix, setNestedProperty };

package/dist/esm/development/extractor.js

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

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

@@ -0,0 +1,4 @@
+export { useFormatter, useTranslations } from './react-client/index.js';
+export { default as NextIntlClientProvider } from './shared/NextIntlClientProvider.js';
+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

@@ -0,0 +1,9 @@
+export { default as useLocale } from './react-server/useLocale.js';
+export { default as useTranslations } from './react-server/useTranslations.js';
+export { default as useFormatter } from './react-server/useFormatter.js';
+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';