@chaoswise/intl 3.1.1 → 3.1.3

package/bin/scripts/util/fixI18nDefaultInFile.js

@@ -35,6 +35,73 @@ const log = require('./log');
 // Chinese character detection regex
 const ZH_REGEX = /[\u4e00-\u9fa5]/;
 
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function buildRawStringLiteral(value, quote) {
+  const q = quote === '"' ? '"' : '\'';
+  const escaped = String(value)
+    .replace(/\\/g, '\\\\')
+    .replace(/\r/g, '\\r')
+    .replace(/\n/g, '\\n')
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+    .replace(new RegExp(escapeRegExp(q), 'g'), `\\${q}`);
+
+  return `${q}${escaped}${q}`;
+}
+
+function hasOwnTranslation(localeMap, key) {
+  return Object.prototype.hasOwnProperty.call(localeMap, key);
+}
+
+function replaceEmbeddedI18nDefaultInText(text, localeMap, opts, missing) {
+  const {
+    i18nObject = 'intl',
+    i18nMethod = 'get',
+    i18nDefaultFunctionKey = 'd',
+  } = opts || {};
+
+  const objectPrefix = i18nObject ? `${escapeRegExp(i18nObject)}\\s*\\.\\s*` : '';
+  const method = escapeRegExp(i18nMethod);
+  const dMethod = escapeRegExp(i18nDefaultFunctionKey);
+
+  const pattern = new RegExp(
+    `${objectPrefix}${method}\\s*\\(\\s*(["'])((?:\\\\.|(?!\\1).)*)\\1\\s*\\)\\s*\\.\\s*${dMethod}\\s*\\(\\s*(["'])((?:\\\\.|(?!\\3).)*)\\3\\s*\\)`,
+    'g'
+  );
+
+  let replaced = 0;
+  const next = text.replace(pattern, (full, keyQuote, rawKey, valueQuote, rawValue) => {
+    const key = rawKey.replace(/\\(["'])/g, '$1');
+    const chinese = rawValue.replace(/\\(["'])/g, '$1');
+
+    if (!ZH_REGEX.test(chinese)) {
+      return full;
+    }
+
+    if (!hasOwnTranslation(localeMap, key)) {
+      missing.push({ key, chinese });
+      return full;
+    }
+    const translation = localeMap[key];
+
+    const escapedTranslation = String(translation)
+      .replace(/\\/g, '\\\\')
+      .replace(new RegExp(valueQuote, 'g'), `\\${valueQuote}`);
+
+    replaced += 1;
+
+    return full.replace(
+      new RegExp(`${escapeRegExp(valueQuote)}((?:\\\\.|(?!${escapeRegExp(valueQuote)}).)*)${escapeRegExp(valueQuote)}\\s*\\)$`),
+      `${valueQuote}${escapedTranslation}${valueQuote})`
+    );
+  });
+
+  return { text: next, replaced };
+}
+
 /**
  * Extract the i18n key from the "inner" `.get('key')` call that wraps a `.d()`.
  *
@@ -145,12 +212,11 @@ module.exports = function fixI18nDefaultInFile(filePath, localeMap, opts) {
       const key = extractI18nKey(node, i18nMethod, i18nDefaultFunctionKey, i18nObject);
       if (!key) return;
 
-      const translation = localeMap[key];
-
-      if (!translation) {
+      if (!hasOwnTranslation(localeMap, key)) {
         missing.push({ key, chinese: arg.value });
         return;
       }
+      const translation = localeMap[key];
 
       // Replace the argument node with a new StringLiteral containing
       // the translation. We use Object.assign to preserve recast's
@@ -160,6 +226,38 @@ module.exports = function fixI18nDefaultInFile(filePath, localeMap, opts) {
       Object.assign(arg, t.stringLiteral(translation), { extra: undefined });
       fixed++;
     },
+    StringLiteral(nodePath) {
+      const node = nodePath.node;
+      if (!node || typeof node.value !== 'string') return;
+      if (!ZH_REGEX.test(node.value)) return;
+
+      const result = replaceEmbeddedI18nDefaultInText(node.value, localeMap, opts, missing);
+      if (result.replaced > 0 && result.text !== node.value) {
+        const raw = node.extra && typeof node.extra.raw === 'string' ? node.extra.raw : '';
+        const originalQuote = raw.startsWith('"') ? '"' : '\'';
+        node.value = result.text;
+        node.extra = {
+          ...(node.extra || {}),
+          rawValue: result.text,
+          raw: buildRawStringLiteral(result.text, originalQuote),
+        };
+        fixed += result.replaced;
+      }
+    },
+    TemplateElement(nodePath) {
+      const node = nodePath.node;
+      if (!node || !node.value || typeof node.value.cooked !== 'string') return;
+      if (!ZH_REGEX.test(node.value.cooked)) return;
+
+      const result = replaceEmbeddedI18nDefaultInText(node.value.cooked, localeMap, opts, missing);
+      if (result.replaced > 0 && result.text !== node.value.cooked) {
+        Object.assign(node, t.templateElement({
+          raw: result.text,
+          cooked: result.text,
+        }, node.tail), { extra: undefined });
+        fixed += result.replaced;
+      }
+    },
   });
 
   if (fixed === 0) {
@@ -167,7 +265,7 @@ module.exports = function fixI18nDefaultInFile(filePath, localeMap, opts) {
   }
 
   // ── Write back using recast (minimal diff) ───────────────────────────
-  const newCode = recast.print(recastAst).code;
+  const newCode = recast.print(recastAst, { quote: 'auto' }).code;
   try {
     fs.writeFileSync(filePath, newCode, { encoding: 'utf-8' });
   } catch (err) {

package/bin/scripts/util/fixZhCnInFile.js

@@ -215,3 +215,293 @@ module.exports = function fixZhCnInFile(filePath, findings, strategy = 'clean')
 
   return patchedCount;
 };
+
+// ─── JSX SVG attribute fix ───────────────────────────────────────────────────
+
+// Strip Chinese + CJK punctuation / fullwidth forms (design-tool residue)
+const ZH_CLEAN_REGEX = /[\u4e00-\u9fa5\u3000-\u303f\uff00-\uffef]/g;
+
+/**
+ * Fix JSX SVG attribute findings (type 'jsx-svg-attr') by stripping Chinese
+ * characters from the string literal values.
+ *
+ * For each finding:
+ *   - strategy 'clean' : strip Chinese (+ CJK punctuation) from the value.
+ *                        If the cleaned value is empty, remove the entire
+ *                        JSX attribute (name + '=' + value).
+ *   - strategy 'remove': remove the entire JSX attribute unconditionally.
+ *
+ * Byte offsets on the finding (start / end) point to the StringLiteral node
+ * including its quote characters, as produced by findZhCnInFile.js.
+ *
+ * @param {string}    filePath  - absolute file path
+ * @param {Finding[]} findings  - array of { type:'jsx-svg-attr', start, end, ... }
+ * @param {'clean'|'remove'} strategy
+ * @returns {number} count of attributes fixed
+ */
+function fixJsxSvgAttrInFile(filePath, findings, strategy = 'clean') {
+  const attrFindings = findings.filter(
+    (f) => f.type === 'jsx-svg-attr' && typeof f.start === 'number' && typeof f.end === 'number'
+  );
+  if (!attrFindings.length) return 0;
+
+  // Defensive dedupe: duplicated ranges can cause second-pass patches to use
+  // stale offsets and accidentally trim following attributes.
+  const dedupMap = new Map();
+  attrFindings.forEach((f) => {
+    const key = `${f.start}:${f.end}`;
+    if (!dedupMap.has(key)) dedupMap.set(key, f);
+  });
+  const uniqueFindings = Array.from(dedupMap.values());
+
+  let source;
+  try {
+    source = fs.readFileSync(filePath, 'utf8');
+  } catch (err) {
+    log.error(`[nozhcn] Cannot read file for fixing: ${filePath} — ${err.message}`);
+    return 0;
+  }
+
+  // Sort descending by start so later patches don't invalidate earlier offsets
+  const sorted = [...uniqueFindings].sort((a, b) => b.start - a.start);
+
+  let patchedCount = 0;
+
+  for (const finding of sorted) {
+    const { start, end } = finding;
+    const original = source.slice(start, end); // e.g. "编组1" (with quotes)
+    if (!original || original.length < 2) continue;
+
+    const quote = original[0]; // '"' or "'"
+    // If boundaries are no longer a string literal, skip safely.
+    if ((quote !== '"' && quote !== "'") || original[original.length - 1] !== quote) {
+      continue;
+    }
+    const rawValue = original.slice(1, -1);
+    const cleaned = strategy === 'remove' ? '' : rawValue.replace(ZH_CLEAN_REGEX, '').trim();
+
+    if (cleaned) {
+      // Just replace the string value in-place
+      source = source.slice(0, start) + quote + cleaned + quote + source.slice(end);
+    } else {
+      // Cleaned value is empty — remove the whole JSX attr: `attrName="value"`
+      // Walk backwards from start to find the beginning of the attribute name.
+      // Source just before start looks like: `... attrName="`
+      let attrEnd = end;
+      let pos = start - 1; // skip the opening quote's predecessor: should be '='
+      if (pos >= 0 && source[pos] === '=') pos--;
+      // Walk backwards past the attribute name characters (word chars, '-', ':')
+      while (pos >= 0 && /[\w:_-]/.test(source[pos])) pos--;
+      // pos now points to the char before the attr name (usually a space/newline)
+      const attrStart = pos + 1;
+
+      // If the attribute is on its own line (only whitespace before it on that
+      // line), remove the entire line to avoid leaving a blank line.
+      let lineStart = pos;
+      while (lineStart > 0 && source[lineStart - 1] !== '\n') lineStart--;
+      const beforeOnLine = source.slice(lineStart, attrStart);
+      const isAloneOnLine = /^\s*$/.test(beforeOnLine);
+      // Also check nothing meaningful follows on the same line
+      let afterEnd = attrEnd;
+      while (afterEnd < source.length && source[afterEnd] !== '\n' && source[afterEnd] !== '\r') afterEnd++;
+      const afterOnLine = source.slice(attrEnd, afterEnd);
+      const nothingAfter = /^\s*$/.test(afterOnLine);
+
+      if (isAloneOnLine && nothingAfter) {
+        // Remove from the start of this line (after previous \n) through the trailing \n
+        const lineEnd = afterEnd < source.length ? afterEnd + 1 : afterEnd;
+        source = source.slice(0, lineStart) + source.slice(lineEnd);
+      } else {
+        // Attribute is inline — just remove attr + one leading whitespace
+        const removeFrom = pos >= 0 && /[\s]/.test(source[pos]) ? pos : attrStart;
+        source = source.slice(0, removeFrom) + source.slice(attrEnd);
+      }
+    }
+
+    patchedCount++;
+  }
+
+  if (patchedCount === 0) return 0;
+
+  try {
+    fs.writeFileSync(filePath, source, { encoding: 'utf-8' });
+  } catch (err) {
+    log.error(`[nozhcn] Cannot write fixed file: ${filePath} — ${err.message}`);
+    return 0;
+  }
+
+  return patchedCount;
+}
+
+/**
+ * Fix JSX SVG metadata text findings (type 'jsx-svg-metadata').
+ *
+ * Strategy:
+ *   - 'empty'  : clear only metadata text content (<title>中文</title> -> <title></title>)
+ *   - 'remove' : remove the whole metadata element (<title>中文</title> -> '')
+ *
+ * @param {string} filePath
+ * @param {Finding[]} findings
+ * @param {'remove'|'empty'} strategy
+ * @returns {number}
+ */
+function fixJsxSvgMetadataInFile(filePath, findings, strategy = 'remove') {
+  if (!strategy) return 0;
+  if (!['remove', 'empty'].includes(strategy)) {
+    log.warnToLog(`[nozhcn] Invalid JSX SVG metadata strategy: ${strategy}, skip auto-fix.`);
+    return 0;
+  }
+
+  const metadataFindings = findings.filter(
+    (f) => f.type === 'jsx-svg-metadata' && typeof f.start === 'number' && typeof f.end === 'number'
+  );
+  if (!metadataFindings.length) return 0;
+
+  let source;
+  try {
+    source = fs.readFileSync(filePath, 'utf8');
+  } catch (err) {
+    log.error(`[nozhcn] Cannot read file for fixing: ${filePath} — ${err.message}`);
+    return 0;
+  }
+
+  let patchedCount = 0;
+
+  if (strategy === 'empty') {
+    // Clear text content only, keep metadata tags.
+    const sorted = [...metadataFindings].sort((a, b) => b.start - a.start);
+    sorted.forEach((f) => {
+      source = source.slice(0, f.start) + source.slice(f.end);
+      patchedCount++;
+    });
+  } else {
+    // 'remove': remove whole metadata elements; dedupe by element range.
+    const ranges = [];
+    const seen = new Set();
+    metadataFindings.forEach((f) => {
+      if (typeof f.metaElementStart !== 'number' || typeof f.metaElementEnd !== 'number') return;
+      const key = `${f.metaElementStart}:${f.metaElementEnd}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      ranges.push({ start: f.metaElementStart, end: f.metaElementEnd });
+    });
+
+    if (!ranges.length) return 0;
+
+    ranges.sort((a, b) => b.start - a.start);
+    ranges.forEach(({ start, end }) => {
+      // If the metadata element occupies a whole line, remove that full line.
+      let lineStart = start;
+      while (lineStart > 0 && source[lineStart - 1] !== '\n') lineStart--;
+      const before = source.slice(lineStart, start);
+      const onlyWhitespaceBefore = /^\s*$/.test(before);
+
+      let lineEnd = end;
+      while (lineEnd < source.length && source[lineEnd] !== '\n') lineEnd++;
+      const after = source.slice(end, lineEnd);
+      const onlyWhitespaceAfter = /^\s*$/.test(after);
+
+      if (onlyWhitespaceBefore && onlyWhitespaceAfter) {
+        const removeEnd = lineEnd < source.length ? lineEnd + 1 : lineEnd;
+        source = source.slice(0, lineStart) + source.slice(removeEnd);
+      } else {
+        source = source.slice(0, start) + source.slice(end);
+      }
+      patchedCount++;
+    });
+  }
+
+  if (patchedCount === 0) return 0;
+
+  try {
+    fs.writeFileSync(filePath, source, { encoding: 'utf-8' });
+  } catch (err) {
+    log.error(`[nozhcn] Cannot write fixed file: ${filePath} — ${err.message}`);
+    return 0;
+  }
+
+  return patchedCount;
+}
+
+/**
+ * Remove console statement findings (type 'console') from a source file.
+ *
+ * We only auto-fix findings that carry ExpressionStatement ranges
+ * (`stmtStart` / `stmtEnd`). This keeps removal safe and predictable.
+ *
+ * @param {string} filePath
+ * @param {Finding[]} findings
+ * @param {'remove'|false} strategy
+ * @returns {number}
+ */
+function fixConsoleZhCnInFile(filePath, findings, strategy = 'remove') {
+  if (!strategy) return 0;
+  if (strategy !== 'remove') {
+    log.warnToLog(`[nozhcn] Invalid console strategy: ${strategy}, skip auto-fix.`);
+    return 0;
+  }
+
+  const consoleFindings = findings.filter(
+    (f) =>
+      f.type === 'console' &&
+      typeof f.stmtStart === 'number' &&
+      typeof f.stmtEnd === 'number'
+  );
+  if (!consoleFindings.length) return 0;
+
+  let source;
+  try {
+    source = fs.readFileSync(filePath, 'utf8');
+  } catch (err) {
+    log.error(`[nozhcn] Cannot read file for fixing: ${filePath} — ${err.message}`);
+    return 0;
+  }
+
+  // Deduplicate statement ranges first (a single console stmt can produce multiple findings).
+  const rangeMap = new Map();
+  consoleFindings.forEach((f) => {
+    const key = `${f.stmtStart}:${f.stmtEnd}`;
+    if (!rangeMap.has(key)) {
+      rangeMap.set(key, { start: f.stmtStart, end: f.stmtEnd });
+    }
+  });
+
+  const ranges = Array.from(rangeMap.values()).sort((a, b) => b.start - a.start);
+  let patchedCount = 0;
+
+  ranges.forEach(({ start, end }) => {
+    let lineStart = start;
+    while (lineStart > 0 && source[lineStart - 1] !== '\n') lineStart--;
+    const before = source.slice(lineStart, start);
+    const onlyWhitespaceBefore = /^\s*$/.test(before);
+
+    let lineEnd = end;
+    while (lineEnd < source.length && source[lineEnd] !== '\n') lineEnd++;
+    const after = source.slice(end, lineEnd);
+    const onlyWhitespaceAfter = /^\s*$/.test(after);
+
+    if (onlyWhitespaceBefore && onlyWhitespaceAfter) {
+      const removeEnd = lineEnd < source.length ? lineEnd + 1 : lineEnd;
+      source = source.slice(0, lineStart) + source.slice(removeEnd);
+    } else {
+      source = source.slice(0, start) + source.slice(end);
+    }
+
+    patchedCount++;
+  });
+
+  if (patchedCount === 0) return 0;
+
+  try {
+    fs.writeFileSync(filePath, source, { encoding: 'utf-8' });
+  } catch (err) {
+    log.error(`[nozhcn] Cannot write fixed file: ${filePath} — ${err.message}`);
+    return 0;
+  }
+
+  return patchedCount;
+}
+
+module.exports.fixJsxSvgAttrInFile = fixJsxSvgAttrInFile;
+module.exports.fixJsxSvgMetadataInFile = fixJsxSvgMetadataInFile;
+module.exports.fixConsoleZhCnInFile = fixConsoleZhCnInFile;

package/bin/scripts/util/makeVisitorDowngrade.js

@@ -0,0 +1,82 @@
+const t = require('@babel/types');
+
+/**
+ * makeVisitorDowngrade
+ *
+ * 将代码中所有孤立 id（missingIdSet 中的 id）的 intl 调用降级回原始字符串字面量，
+ * 便于后续重新执行 collect → update 完成国际化。
+ *
+ * 支持两种形态：
+ *
+ *   形态 A（有 .d() 兜底）：
+ *     intl.get('orphan-id').d('确认提交')
+ *     → '确认提交'
+ *
+ *   形态 B（裸 id，无默认文案）：
+ *     intl.get('orphan-id')
+ *     → 无法恢复文案，记录到 noDefaultIds，由调用方输出警告，代码不修改
+ *
+ * @param {{ i18nObject, i18nMethod, i18nDefaultFunctionKey }} opts  来自 conf
+ * @param {{ missingIdSet: Set<string>, noDefaultIds: string[] }} returns
+ */
+module.exports = function makeVisitorDowngrade(
+  { i18nObject, i18nMethod, i18nDefaultFunctionKey },
+  returns
+) {
+  const { missingIdSet, noDefaultIds } = returns;
+
+  /**
+   * 判断一个节点是否是 intl.get('xxx') 调用，
+   * 返回第一个参数的字符串值，否则返回 null。
+   */
+  function matchIntlCall(node) {
+    if (
+      node.type === 'CallExpression' &&
+      ((node.callee.type === 'MemberExpression' &&
+        node.callee.object.name === i18nObject &&
+        node.callee.property.name === i18nMethod) ||
+        (!i18nObject &&
+          node.callee.type === 'Identifier' &&
+          node.callee.name === i18nMethod))
+    ) {
+      const firstArg = node.arguments[0];
+      if (firstArg && firstArg.type === 'StringLiteral') {
+        return firstArg.value;
+      }
+    }
+    return null;
+  }
+
+  return {
+    // 形态 A：intl.get('orphan-id').d('默认文案')
+    // 对应 AST：CallExpression { callee: MemberExpression('.d'), object: intl.get(...) }
+    CallExpression(path) {
+      const { node } = path;
+
+      if (
+        node.callee.type === 'MemberExpression' &&
+        node.callee.property.name === i18nDefaultFunctionKey &&
+        node.callee.object.type === 'CallExpression'
+      ) {
+        const id = matchIntlCall(node.callee.object);
+        if (id && missingIdSet.has(id)) {
+          // 取 .d() 的第一个参数作为恢复后的字符串
+          const defaultArg = node.arguments[0];
+          if (defaultArg && defaultArg.type === 'StringLiteral') {
+            returns.hasTouch = true;
+            path.replaceWith(t.StringLiteral(defaultArg.value));
+            path.skip();
+            return;
+          }
+        }
+      }
+
+      // 形态 B：裸 intl.get('orphan-id')，无 .d()
+      const id = matchIntlCall(node);
+      if (id && missingIdSet.has(id)) {
+        // 无法恢复文案，记录警告，不修改代码
+        noDefaultIds.push({ id, loc: node.loc });
+      }
+    },
+  };
+};

package/bin/scripts/util/transformAst.js

@@ -17,6 +17,7 @@ const presetTypescript = require("@babel/preset-typescript").default;
 
 const makeVisitorCollect = require("./makeVisitorCollect");
 const makeVisitorUpdate = require("./makeVisitorUpdate");
+const makeVisitorDowngrade = require("./makeVisitorDowngrade");
 const log = require("./log");
 
 // 获取文件中需要忽略转化通用国际化API规范的所有行号
@@ -84,7 +85,7 @@ function getIgnoreLines(ast) {
   return ignoreLines;
 }
 
-module.exports = function (type, files = [], conf = {}, replaceWords) {
+module.exports = function (type, files = [], conf = {}, replaceWords, extraData) {
   const {
     entry,
     output,
@@ -152,6 +153,11 @@ module.exports = function (type, files = [], conf = {}, replaceWords) {
       hasImport: false, // 是否已经引入通用国际化API，import {init} from ...;
       hasTouch: false, // 是否存在需要替换的词条
     };
+    // downgrade 模式：注入孤立 id 集合和无默认文案收集数组
+    if (type === "downgrade") {
+      r.missingIdSet = replaceWords; // 复用 replaceWords 参数位传入 Set<string>
+      r.noDefaultIds = extraData;   // 无法恢复的裸 id 收集数组
+    }
     const sourceCode = fs.readFileSync(filePath, "utf8");
 
     let ast;
@@ -178,6 +184,8 @@ module.exports = function (type, files = [], conf = {}, replaceWords) {
     let makeVisitor = makeVisitorCollect;
     if (type === "update") {
       makeVisitor = makeVisitorUpdate;
+    } else if (type === "downgrade") {
+      makeVisitor = makeVisitorDowngrade;
     }
 
     try {
@@ -192,7 +200,7 @@ module.exports = function (type, files = [], conf = {}, replaceWords) {
 
     // 不传入需要替换的文词条则不进行文件修改
     // 在只需要提取中文词条的情况下不传入replaceWords
-    if (!replaceWords) return;
+    if (type !== "downgrade" && !replaceWords) return;
 
     // 使用 recast 输出代码，仅重新打印被修改的 AST 节点，保留原始格式
     let code = recast.print(recastAst).code;
@@ -200,6 +208,7 @@ module.exports = function (type, files = [], conf = {}, replaceWords) {
     if (!r.hasTouch) {
       code = sourceCode;
     } else if (
+      type !== "downgrade" &&
       !r.hasImport &&
       !file.special &&
       importCode &&