next-intl 4.4.0 → 4.5.0

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

@@ -0,0 +1,66 @@
+/**
+ * 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
+      });
+      if (this.pendingResolvers.length === 1 && !this.isSaving) {
+        // No pending saves and not currently saving, save immediately
+        this.executeSave(saveTask);
+      } else if (this.pendingResolvers.length > 1) {
+        // Multiple pending saves, schedule/reschedule save
+        this.scheduleSave(saveTask);
+      }
+    });
+  }
+  scheduleSave(saveTask) {
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout);
+    }
+    this.saveTimeout = setTimeout(() => {
+      this.executeSave(saveTask);
+    }, this.delayMs);
+  }
+  async executeSave(saveTask) {
+    if (this.isSaving) {
+      return;
+    }
+    this.isSaving = true;
+    try {
+      const result = await saveTask();
+
+      // Resolve all pending promises with the same result
+      this.pendingResolvers.forEach(({
+        resolve
+      }) => resolve(result));
+    } catch (error) {
+      // Reject all pending promises with the same error
+      this.pendingResolvers.forEach(({
+        reject
+      }) => reject(error));
+    } finally {
+      this.pendingResolvers = [];
+      this.isSaving = false;
+    }
+  }
+  destroy() {
+    if (this.saveTimeout) {
+      clearTimeout(this.saveTimeout);
+      this.saveTimeout = undefined;
+    }
+    this.pendingResolvers = [];
+    this.isSaving = false;
+  }
+}
+
+export { SaveScheduler as default };

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

@@ -0,0 +1,35 @@
+import path from 'path';
+import formatters from './formatters/index.js';
+
+let cachedFormatter = null;
+async function getFormatter(options) {
+  if (!cachedFormatter) {
+    const FormatterClass = (await formatters[options.messages.format]()).default;
+    cachedFormatter = new FormatterClass();
+  }
+  return cachedFormatter;
+}
+
+/**
+ * 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();
+  getFormatter(options).then(formatter => {
+    const locale = path.basename(this.resourcePath, formatter.EXTENSION);
+    const jsonString = formatter.toJSONString(source, {
+      locale
+    });
+
+    // https://v8.dev/blog/cost-of-javascript-2019#json
+    const result = `export default JSON.parse(${JSON.stringify(jsonString)});`;
+    callback(null, result);
+  }).catch(callback);
+}
+
+export { catalogLoader as default };

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

@@ -0,0 +1,8 @@
+import ExtractionCompiler from './ExtractionCompiler.js';
+
+async function extractMessages(params) {
+  const compiler = new ExtractionCompiler(params);
+  await compiler.extract();
+}
+
+export { extractMessages as default };

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

@@ -0,0 +1,22 @@
+import ExtractionCompiler from './ExtractionCompiler.js';
+
+// This instance:
+// - Remains available through HMR
+// - Is the same across react-client and react-server
+// - Is only lost when the dev server restarts (e.g. due to change to Next.js config)
+let compiler;
+function extractionLoader(source) {
+  const options = this.getOptions();
+  const callback = this.async();
+  if (!compiler) {
+    compiler = new ExtractionCompiler(options, {
+      // Avoid rollup's `replace` plugin to compile this away
+      isDevelopment: process.env['NODE_ENV'.trim()] === 'development'
+    });
+  }
+  compiler.compile(this.resourcePath, source).then(result => {
+    callback(null, result);
+  }).catch(callback);
+}
+
+export { extractionLoader as default };

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

@@ -0,0 +1,18 @@
+class ASTScope {
+  vars = (() => new Map())();
+  constructor(parent) {
+    this.parent = parent;
+  }
+  define(name, kind, namespace) {
+    this.vars.set(name, {
+      kind,
+      namespace
+    });
+  }
+  lookup(name) {
+    if (this.vars.has(name)) return this.vars.get(name);
+    return this.parent?.lookup(name);
+  }
+}
+
+export { ASTScope as default };

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

@@ -0,0 +1,11 @@
+import crypto from 'crypto';
+
+class KeyGenerator {
+  static generate(message) {
+    const hash = crypto.createHash('sha512').update(message).digest();
+    const base64 = hash.toString('base64');
+    return base64.slice(0, 6);
+  }
+}
+
+export { KeyGenerator 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,402 @@
+import path from 'path';
+import { parse, print } from '@swc/core';
+import { warn } from '../../plugin/utils.js';
+import ASTScope from './ASTScope.js';
+import KeyGenerator from './KeyGenerator.js';
+import LRUCache from './LRUCache.js';
+
+class MessageExtractor {
+  static NAMESPACE_SEPARATOR = '.';
+  compileCache = (() => new LRUCache(750))();
+  constructor(opts) {
+    this.isDevelopment = opts.isDevelopment;
+    this.projectRoot = opts.projectRoot;
+  }
+  async processFileContent(absoluteFilePath, source) {
+    const cacheKey = source;
+    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: [],
+        source
+      };
+    }
+    const ast = await parse(source, {
+      syntax: 'typescript',
+      tsx: true,
+      target: 'es2022',
+      decorators: true
+    });
+    const relativeFilePath = path.relative(this.projectRoot, absoluteFilePath);
+    const processResult = await this.processAST(ast, relativeFilePath);
+    const finalResult = processResult.source ? processResult : {
+      ...processResult,
+      source
+    };
+    this.compileCache.set(cacheKey, finalResult);
+    return finalResult;
+  }
+  async processAST(ast, filePath) {
+    const results = [];
+    let hookLocalName = null;
+    let hookType = null;
+    const isDevelopment = this.isDevelopment;
+    const scopeStack = [new ASTScope()];
+    function currentScope() {
+      return scopeStack[scopeStack.length - 1];
+    }
+    function createUndefinedArgument() {
+      return {
+        expression: {
+          type: 'Identifier',
+          value: 'undefined',
+          optional: false,
+          ctxt: 1,
+          span: {
+            start: 0,
+            end: 0,
+            ctxt: 0
+          }
+        }
+      };
+    }
+    function extractStaticString(value) {
+      if (value.type === 'StringLiteral') {
+        return value.value;
+      } else if (value.type === 'TemplateLiteral') {
+        const templateLiteral = value;
+        // Only handle simple template literals without expressions
+        if (templateLiteral.expressions.length === 0 && templateLiteral.quasis.length === 1) {
+          return templateLiteral.quasis[0].cooked || templateLiteral.quasis[0].raw;
+        }
+      }
+      return null;
+    }
+    function visit(node) {
+      if (typeof node !== 'object') return;
+      switch (node.type) {
+        case 'ImportDeclaration':
+          {
+            const decl = node;
+            if (decl.source.value === 'next-intl') {
+              for (const spec of decl.specifiers) {
+                if (spec.type === 'ImportSpecifier') {
+                  const importedName = spec.imported?.value;
+                  const localName = spec.local.value;
+                  if (importedName === 'useExtracted' || localName === 'useExtracted') {
+                    hookLocalName = localName;
+                    hookType = 'useTranslations';
+
+                    // Transform import to useTranslations
+                    spec.imported = undefined;
+                    spec.local.value = 'useTranslations';
+                  }
+                }
+              }
+            } else if (decl.source.value === 'next-intl/server') {
+              for (const spec of decl.specifiers) {
+                if (spec.type === 'ImportSpecifier') {
+                  const importedName = spec.imported?.value;
+                  const localName = spec.local.value;
+                  if (importedName === 'getExtracted' || localName === 'getExtracted') {
+                    hookLocalName = localName;
+                    hookType = 'getTranslations';
+
+                    // Transform import to getTranslations
+                    spec.imported = undefined;
+                    spec.local.value = 'getTranslations';
+                  }
+                }
+              }
+            }
+            break;
+          }
+        case 'VariableDeclarator':
+          {
+            const decl = node;
+            let callExpr = null;
+
+            // Handle direct CallExpression: const t = useExtracted();
+            if (decl.init?.type === 'CallExpression' && decl.init.callee.type === 'Identifier' && decl.init.callee.value === hookLocalName) {
+              callExpr = decl.init;
+            }
+            // Handle AwaitExpression: const t = await getExtracted();
+            else if (decl.init?.type === 'AwaitExpression' && decl.init.argument.type === 'CallExpression' && decl.init.argument.callee.type === 'Identifier' && decl.init.argument.callee.value === hookLocalName) {
+              callExpr = decl.init.argument;
+            }
+            if (callExpr && decl.id.type === 'Identifier') {
+              // Extract namespace from first argument if present
+              let namespace;
+              if (callExpr.arguments.length > 0) {
+                const firstArg = callExpr.arguments[0].expression;
+                if (firstArg.type === 'StringLiteral') {
+                  namespace = firstArg.value;
+                } else if (firstArg.type === 'ObjectExpression') {
+                  const objectExpression = firstArg;
+                  for (const prop of objectExpression.properties) {
+                    if (prop.type === 'KeyValueProperty') {
+                      const key = prop.key;
+                      if (key.type === 'Identifier' && key.value === 'namespace') {
+                        const staticNamespace = extractStaticString(prop.value);
+                        if (staticNamespace != null) {
+                          namespace = staticNamespace;
+                        }
+                        break;
+                      }
+                    }
+                  }
+                }
+              }
+              currentScope().define(decl.id.value, 'translator', namespace);
+
+              // Transform the call based on the hook type
+              if (hookType) {
+                callExpr.callee.value = hookType;
+              }
+            }
+            break;
+          }
+        case 'CallExpression':
+          {
+            const call = node;
+            let isTranslatorCall = false;
+            let namespace;
+
+            // Handle Identifier case: t("message")
+            if (call.callee.type === 'Identifier') {
+              const name = call.callee.value;
+              const resolved = currentScope().lookup(name);
+              isTranslatorCall = resolved?.kind === 'translator';
+              namespace = resolved?.namespace;
+            }
+
+            // Handle MemberExpression case: t.rich, t.markup, or t.has
+            else if (call.callee.type === 'MemberExpression') {
+              const memberExpr = call.callee;
+              if (memberExpr.object.type === 'Identifier' && memberExpr.property.type === 'Identifier') {
+                const objectName = memberExpr.object.value;
+                const propertyName = memberExpr.property.value;
+                const resolved = currentScope().lookup(objectName);
+                isTranslatorCall = resolved?.kind === 'translator' && (propertyName === 'rich' || propertyName === 'markup' || propertyName === 'has');
+                namespace = resolved?.namespace;
+              }
+            }
+            if (isTranslatorCall) {
+              const arg0 = call.arguments[0]?.expression;
+              let messageText = null;
+              let explicitId = null;
+              let description = null;
+              let valuesNode = null;
+              let formatsNode = null;
+              function warnDynamicExpression(expressionNode) {
+                const hasSpan = 'span' in expressionNode && expressionNode.span && typeof expressionNode.span === 'object' && 'start' in expressionNode.span;
+                const location = hasSpan ? path.basename(filePath) : undefined;
+                warn((location ? `${location}: ` : '') + 'Cannot extract message from dynamic expression, messages need to be statically analyzable. If you need to provide runtime values, pass them as a separate argument.');
+              }
+
+              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+              if (arg0) {
+                // Handle object syntax: t({id: 'key', message: 'text'})
+                if (arg0.type === 'ObjectExpression') {
+                  const objectExpression = arg0;
+
+                  // Look for id, message, values, and formats properties
+                  for (const prop of objectExpression.properties) {
+                    if (prop.type === 'KeyValueProperty') {
+                      const key = prop.key;
+                      if (key.type === 'Identifier' && key.value === 'id') {
+                        const staticId = extractStaticString(prop.value);
+                        if (staticId !== null) {
+                          explicitId = staticId;
+                        }
+                      } else if (key.type === 'Identifier' && key.value === 'message') {
+                        const staticMessage = extractStaticString(prop.value);
+                        if (staticMessage != null) {
+                          messageText = staticMessage;
+                        } else {
+                          warnDynamicExpression(prop.value);
+                        }
+                      } else if (key.type === 'Identifier' && key.value === 'description') {
+                        const staticDescription = extractStaticString(prop.value);
+                        if (staticDescription != null) {
+                          description = staticDescription;
+                        } else {
+                          warnDynamicExpression(prop.value);
+                        }
+                      } else if (key.type === 'Identifier' && key.value === 'values') {
+                        valuesNode = prop.value;
+                      } else if (key.type === 'Identifier' && key.value === 'formats') {
+                        formatsNode = prop.value;
+                      }
+                    }
+                  }
+                }
+
+                // Handle string syntax: t('text') or t(`text`)
+                else {
+                  const staticString = extractStaticString(arg0);
+                  if (staticString != null) {
+                    messageText = staticString;
+                  } else {
+                    // Dynamic expression (Identifier, CallExpression, BinaryExpression, etc.)
+                    warnDynamicExpression(arg0);
+                  }
+                }
+              }
+              if (messageText) {
+                const callKey = explicitId || KeyGenerator.generate(messageText);
+                const fullKey = namespace ? [namespace, callKey].join(MessageExtractor.NAMESPACE_SEPARATOR) : callKey;
+                const message = {
+                  id: fullKey,
+                  message: messageText,
+                  references: [{
+                    path: filePath
+                  }]
+                };
+                if (description) {
+                  message.description = description;
+                }
+                results.push(message);
+
+                // Transform the argument based on type
+                if (arg0.type === 'StringLiteral') {
+                  arg0.value = callKey;
+                  arg0.raw = undefined;
+                } else if (arg0.type === 'TemplateLiteral') {
+                  // Replace template literal with string literal
+                  Object.assign(arg0, {
+                    type: 'StringLiteral',
+                    value: callKey,
+                    raw: undefined
+                  });
+                } else if (arg0.type === 'ObjectExpression') {
+                  // Transform object expression to individual parameters
+                  // Replace the object with the key as first argument
+                  Object.assign(arg0, {
+                    type: 'StringLiteral',
+                    value: callKey,
+                    raw: undefined
+                  });
+
+                  // Add values as second argument if present
+                  if (valuesNode) {
+                    if (call.arguments.length < 2) {
+                      call.arguments.push({
+                        // @ts-expect-error -- Node type compatible with Expression
+                        expression: valuesNode
+                      });
+                    } else {
+                      // @ts-expect-error -- Node type compatible with Expression
+                      call.arguments[1].expression = valuesNode;
+                    }
+                  }
+
+                  // Add formats as third argument if present
+                  if (formatsNode) {
+                    // Ensure we have a second argument (values or undefined)
+                    while (call.arguments.length < 2) {
+                      call.arguments.push(createUndefinedArgument());
+                    }
+                    if (call.arguments.length < 3) {
+                      // Append argument
+                      call.arguments.push({
+                        // @ts-expect-error -- Node type compatible with Expression
+                        expression: formatsNode
+                      });
+                    } else {
+                      // Replace argument
+                      // @ts-expect-error -- Node type compatible with Expression
+                      call.arguments[2].expression = formatsNode;
+                    }
+                  }
+                }
+
+                // Check if this is a t.has call (which doesn't need fallback)
+                const isHasCall = call.callee.type === 'MemberExpression' && call.callee.property.type === 'Identifier' && call.callee.property.value === 'has';
+
+                // Add fallback message as fourth parameter in development mode (except for t.has)
+                if (isDevelopment && !isHasCall) {
+                  // Ensure we have at least 3 arguments
+                  while (call.arguments.length < 3) {
+                    call.arguments.push(createUndefinedArgument());
+                  }
+
+                  // Add fallback message
+                  call.arguments.push({
+                    expression: {
+                      type: 'StringLiteral',
+                      value: messageText,
+                      raw: JSON.stringify(messageText),
+                      // @ts-expect-error -- Seems required
+                      ctxt: 1,
+                      span: {
+                        start: 0,
+                        end: 0,
+                        ctxt: 0
+                      }
+                    }
+                  });
+                }
+              }
+            }
+            break;
+          }
+        case 'FunctionDeclaration':
+        case 'FunctionExpression':
+        case 'ArrowFunctionExpression':
+        case 'BlockStatement':
+          {
+            scopeStack.push(new ASTScope(currentScope()));
+            for (const key of Object.keys(node)) {
+              const child = node[key];
+              if (Array.isArray(child)) {
+                child.forEach(item => {
+                  if (item && typeof item === 'object') {
+                    if ('expression' in item && typeof item.expression === 'object' && 'type' in item.expression) {
+                      visit(item.expression);
+                    } else if ('type' in item) {
+                      visit(item);
+                    }
+                  }
+                });
+              } else if (child && typeof child === 'object' && 'type' in child) {
+                visit(child);
+              }
+            }
+            scopeStack.pop();
+            return;
+          }
+      }
+
+      // Generic recursion
+      for (const key of Object.keys(node)) {
+        const child = node[key];
+        if (Array.isArray(child)) {
+          child.forEach(item => {
+            if (item && typeof item === 'object') {
+              if ('expression' in item && item.expression && typeof item.expression === 'object' && 'type' in item.expression) {
+                visit(item.expression);
+              } else if ('type' in item) {
+                visit(item);
+              }
+            }
+          });
+        } else if (child && typeof child === 'object' && 'type' in child) {
+          visit(child);
+        }
+      }
+    }
+    visit(ast);
+    return {
+      messages: results,
+      source: (await print(ast)).code
+    };
+  }
+}
+
+export { MessageExtractor as default };

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

@@ -0,0 +1,3 @@
+class Formatter {}
+
+export { Formatter as default };

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

@@ -0,0 +1,42 @@
+import { setNestedProperty } from '../utils/ObjectUtils.js';
+import Formatter from './Formatter.js';
+import { getSortedMessages } from './utils.js';
+
+class JSONFormatter extends Formatter {
+  static NAMESPACE_SEPARATOR = '.';
+  EXTENSION = '.json';
+  parse(source) {
+    const json = JSON.parse(source);
+    const messages = [];
+    this.traverseMessages(json, (message, id) => {
+      messages.push({
+        id,
+        message
+      });
+    });
+    return messages;
+  }
+  serialize(messages) {
+    const root = {};
+    for (const message of getSortedMessages(messages)) {
+      setNestedProperty(root, message.id, message.message);
+    }
+    return JSON.stringify(root, null, 2);
+  }
+  toJSONString(source) {
+    return source;
+  }
+  traverseMessages(obj, callback, path = '') {
+    for (const key of Object.keys(obj)) {
+      const newPath = path ? path + JSONFormatter.NAMESPACE_SEPARATOR + key : key;
+      const value = obj[key];
+      if (typeof value === 'string') {
+        callback(value, newPath);
+      } else if (typeof value === 'object') {
+        this.traverseMessages(value, callback, newPath);
+      }
+    }
+  }
+}
+
+export { JSONFormatter as default };