@chaoswise/intl 3.1.2 → 3.1.3

package/bin/chaoswise-intl.js

@@ -4,6 +4,7 @@ const runUpdate = require('./scripts/update');
 const runInitConfig = require('./scripts/initConfig');
 const runAddLocale = require('./scripts/addLocale');
 const runNoZhCn = require('./scripts/nozhcn');
+const runNoZhCnGuard = require('./scripts/nozhcnGuard');
 const runVerify = require('./scripts/verify');
 
 const SCRIPTS = ['intl', 'collect', 'update', 'nozhcn', 'addLocale', 'init', 'verify'];
@@ -45,9 +46,15 @@ if (script === 'verify') {
 //   chaoswise-intl nozhcn check     → same as above
 //   chaoswise-intl nozhcn fix       → auto-fix comments, report remaining issues
 //   chaoswise-intl nozhcn report    → non-blocking scan, output JSON report
+//   chaoswise-intl nozhcn guard     → repository-level zero-Chinese guard (supports --report/--config/...)
 if (script === 'nozhcn') {
   // The sub-mode is the argument after 'nozhcn', default to 'check'
   const modeArg = args[scriptIndex + 1];
+  if (modeArg === 'guard') {
+    const guardArgs = args.slice(scriptIndex + 2);
+    runNoZhCnGuard(guardArgs);
+    return;
+  }
   const validModes = ['check', 'fix', 'report'];
   const mode = validModes.includes(modeArg) ? modeArg : 'check';
   runNoZhCn(mode);

package/bin/scripts/conf/default.js

@@ -104,8 +104,9 @@ module.exports = function (excludes = []) {
     //   'string'     - 字符串字面量
     //   'template'   - 模板字符串
     //   'jsx'        - JSX 文本内容
+    //   'console'    - console.* 日志中的中文（可自动清理）
     //   'identifier' - 标识符名称（极少出现，需手动修复）
-    noZhCnCheckTypes: ['comment', 'string', 'template', 'jsx'],
+    noZhCnCheckTypes: ['comment', 'string', 'template', 'jsx', 'console'],
 
     // 注释中文修复策略（fix 模式生效）:
     //   'clean'  - 仅删除中文字符，保留非中文内容；若注释全为中文则整条删除
@@ -137,12 +138,25 @@ module.exports = function (excludes = []) {
     //   'empty'  - 保留元素但清空内容：<title>搜索</title> → <title></title>
     noZhCnSvgMetadataStrategy: 'remove',
 
+    // JSX 内联 <svg> 的元数据元素（<title>、<desc>、<metadata>）修复策略（fix 模式生效）:
+    //   'remove' - 删除整个元素
+    //   'empty'  - 保留元素但清空内容
+    //   false    - 不自动修复 JSX 内联 SVG metadata（仅报告）
+    //   undefined/null - 跟随 noZhCnSvgMetadataStrategy（向后兼容）
+    noZhCnJsxSvgMetadataStrategy: null,
+
     // SVG 属性中文修复策略（fix 模式生效）:
     //   'clean'  - 删除属性值中的中文字符（及 CJK 标点），清理后为空则移除整个属性；
     //              若修改了 id 属性，同步更新 SVG 内部引用（url(#…), href）
     //   'remove' - 移除包含中文的属性
     //   false    - 不自动修复属性中的中文
-    noZhCnSvgAttrStrategy: 'clean',  };
+    noZhCnSvgAttrStrategy: 'clean',
+
+    // console 中文日志修复策略（fix 模式生效）:
+    //   'remove' - 删除包含中文的 console 语句（仅处理可安全定位的表达式语句）
+    //   false    - 不自动修复 console 中文日志（仅报告）
+    noZhCnConsoleStrategy: 'remove',
+  };
 
   excludes.forEach((key) => delete config[key]);
 

package/bin/scripts/nozhcn.js

@@ -26,6 +26,9 @@ const getConf = require('./conf');
 const { targetEntryFiles } = require('./util/getTargetFiles');
 const findZhCnInFile = require('./util/findZhCnInFile');
 const fixZhCnInFile = require('./util/fixZhCnInFile');
+const { fixJsxSvgAttrInFile } = require('./util/fixZhCnInFile');
+const { fixJsxSvgMetadataInFile } = require('./util/fixZhCnInFile');
+const { fixConsoleZhCnInFile } = require('./util/fixZhCnInFile');
 const fixI18nDefaultInFile = require('./util/fixI18nDefaultInFile');
 const findZhCnInSvgFile = require('./util/findZhCnInSvgFile');
 const fixZhCnInSvgFile = require('./util/fixZhCnInSvgFile');
@@ -35,12 +38,15 @@ const file = require('./util/file');
 // ─── Display labels ──────────────────────────────────────────────────────────
 
 const TYPE_LABEL = {
-  comment:    'Comment   ',
-  string:     'String    ',
-  template:   'Template  ',
-  jsx:        'JSX Text  ',
-  'jsx-svg':  'JSX SVG   ',
-  identifier: 'Identifier',
+  comment:        'Comment     ',
+  string:         'String      ',
+  template:       'Template    ',
+  jsx:            'JSX Text    ',
+  'jsx-svg':      'JSX SVG     ',
+  'jsx-svg-attr': 'JSX SVG Attr',
+  'jsx-svg-metadata': 'JSX SVG Meta',
+  console:        'Console Log ',
+  identifier:     'Identifier  ',
   'svg-comment':  'SVG Comment ',
   'svg-metadata': 'SVG Metadata',
   'svg-text':     'SVG Text    ',
@@ -53,6 +59,9 @@ const TYPE_COLOR = {
   template:       chalk.yellow,
   jsx:            chalk.cyan,
   'jsx-svg':      chalk.magenta,
+  'jsx-svg-attr': chalk.magenta,
+  'jsx-svg-metadata': chalk.gray,
+  console:        chalk.blue,
   identifier:     chalk.red,
   'svg-comment':  chalk.gray,
   'svg-metadata': chalk.gray,
@@ -61,8 +70,18 @@ const TYPE_COLOR = {
 };
 
 // Types that can be auto-fixed by nozhcn fix
-// Note: 'svg-attr' is conditionally fixable when noZhCnSvgAttrStrategy is set
-const AUTO_FIXABLE_TYPES = new Set(['comment', 'svg-comment', 'svg-metadata', 'svg-attr']);
+// Note:
+// - 'svg-attr' / 'jsx-svg-attr' are conditionally fixable when noZhCnSvgAttrStrategy is set
+// - 'svg-metadata' / 'jsx-svg-metadata' are conditionally fixable when noZhCnSvgMetadataStrategy is set
+const AUTO_FIXABLE_TYPES = new Set([
+  'comment',
+  'svg-comment',
+  'svg-metadata',
+  'svg-attr',
+  'jsx-svg-attr',
+  'jsx-svg-metadata',
+  'console',
+]);
 
 // Types that `collect` script can handle
 const COLLECT_TYPES = new Set(['string', 'template', 'jsx']);
@@ -163,13 +182,23 @@ function printSummary(findings, mode, autoFixedCount, i18nDefaultFixed) {
     if (svgManualNeeded) {
       console.log(
         chalk.dim(
-          '  Tip: SVG text/attribute occurrences require manual handling.\n' +
-          '       For standalone .svg files, run fix to clean comments/metadata;\n' +
+          '  Tip: SVG visible text occurrences require manual handling.\n' +
+          '       For standalone .svg files, run fix to clean comments/metadata/attrs;\n' +
           '       for <text> content, consider replacing with a JS-driven label.'
         )
       );
     }
 
+    const jsxSvgAttrNeeded = findings.some((f) => f.type === 'jsx-svg-attr');
+    if (jsxSvgAttrNeeded) {
+      console.log(
+        chalk.dim(
+          "  Tip: JSX SVG attribute values (e.g. id=\"编组1\") are design-tool layer name artifacts.\n" +
+          "       Run 'chaoswise-intl nozhcn fix' to auto-strip Chinese characters from them."
+        )
+      );
+    }
+
     const identifierFound = findings.some((f) => f.type === 'identifier');
     if (identifierFound) {
       console.log(
@@ -201,7 +230,9 @@ module.exports = function noZhCn(mode) {
     noZhCnDefaultLang = null,
     noZhCnIncludeSvg = false,
     noZhCnSvgMetadataStrategy = 'remove',
+    noZhCnJsxSvgMetadataStrategy = null,
     noZhCnSvgAttrStrategy = 'clean',
+    noZhCnConsoleStrategy = 'remove',
     localeOutput = 'src/public',
     primaryRegx,
     babelPresets,
@@ -285,9 +316,9 @@ module.exports = function noZhCn(mode) {
 
   // ── Phase 2: Auto-fix (fix mode only) ────────────────────────────────────
   //
-  // All fix sub-phases (2 / 2b / 2c) run first WITHOUT intermediate re-scans.
-  // A single final re-scan at the end produces accurate remaining findings.
-  // This avoids up to 3 redundant full-project AST parses on large codebases.
+  // Most fix sub-phases run without full-project intermediate re-scans.
+  // For offset-based JS/TS fixers (console / jsx-svg-attr / jsx-svg-metadata),
+  // we re-scan only affected files right before patching to avoid stale ranges.
 
   let autoFixedCount = 0;
   let i18nDefaultFixed = 0;
@@ -296,6 +327,15 @@ module.exports = function noZhCn(mode) {
 
   if (mode === 'fix') {
     let anyFixApplied = false;
+    function getLatestFindingsByType(filePath, type) {
+      const result = findZhCnInFile(filePath, scanOpts);
+      if (result.error) {
+        errorFiles.push({ filePath, error: result.error });
+        return [];
+      }
+      return result.findings.filter((f) => f.type === type);
+    }
+
     // ── Phase 2a: Fix comments in JS/TS files ─────────────────────────────
     const commentByFile = new Map();
     allFindings.forEach((f) => {
@@ -309,6 +349,24 @@ module.exports = function noZhCn(mode) {
     });
     if (autoFixedCount > 0) anyFixApplied = true;
 
+    // ── Phase 2a2: Remove Chinese console logs in JS/TS files ───────────
+    if (noZhCnConsoleStrategy) {
+      const consoleFiles = new Set();
+      allFindings.forEach((f) => {
+        if (f.type !== 'console') return;
+        consoleFiles.add(f.filePath);
+      });
+
+      let consoleFixedCount = 0;
+      consoleFiles.forEach((fp) => {
+        const findings = getLatestFindingsByType(fp, 'console');
+        if (!findings.length) return;
+        consoleFixedCount += fixConsoleZhCnInFile(fp, findings, noZhCnConsoleStrategy);
+      });
+      autoFixedCount += consoleFixedCount;
+      if (consoleFixedCount > 0) anyFixApplied = true;
+    }
+
     // ── Phase 2b: Replace .d('Chinese') with translations ─────────────────
     if (noZhCnDefaultLang) {
       const localePath = path.resolve(
@@ -333,10 +391,13 @@ module.exports = function noZhCn(mode) {
 
         if (localeMap) {
           const fixOpts = { i18nObject, i18nMethod, i18nDefaultFunctionKey, babelPresets, babelPlugins };
-          // Collect JS/TS file paths from initial findings (exclude svg-* types)
-          const filesToFix = new Set(
-            allFindings.filter((f) => !f.type.startsWith('svg-')).map((f) => f.filePath)
-          );
+          // Use ALL scanned files rather than only those with findings.
+          // When noZhCnIgnoreI18nDefault:true (the default), the initial Phase-1 scan
+          // blanks out .d('中文') before checking, so files whose ONLY Chinese text is
+          // inside .d() calls produce zero findings and would be silently skipped.
+          // fixI18nDefaultInFile has a cheap fast-path (no Chinese → early return),
+          // so scanning all files here causes no meaningful performance cost.
+          const filesToFix = new Set(files.map(({ filePath: fp }) => fp));
           filesToFix.forEach((fp) => {
             const result = fixI18nDefaultInFile(fp, localeMap, fixOpts);
             i18nDefaultFixed += result.fixed;
@@ -380,6 +441,53 @@ module.exports = function noZhCn(mode) {
       if (svgFixedCount > 0) anyFixApplied = true;
     }
 
+    // ── Phase 2d: Fix JSX SVG attribute strings in JS/TS files ───────────
+    // e.g. <svg id="编组1"> → <svg id="1"> (strip Chinese layer-name artifacts)
+    if (noZhCnSvgAttrStrategy) {
+      const jsxSvgAttrFiles = new Set();
+      allFindings.forEach((f) => {
+        if (f.type !== 'jsx-svg-attr') return;
+        jsxSvgAttrFiles.add(f.filePath);
+      });
+
+      jsxSvgAttrFiles.forEach((fp) => {
+        const findings = getLatestFindingsByType(fp, 'jsx-svg-attr');
+        if (!findings.length) return;
+        const fixed = fixJsxSvgAttrInFile(fp, findings, noZhCnSvgAttrStrategy);
+        svgFixedCount += fixed;
+      });
+      if (svgFixedCount > 0) anyFixApplied = true;
+    }
+
+    // ── Phase 2e: Fix JSX SVG metadata text in JS/TS files ───────────────
+    // e.g. <title>添加icon</title> (inside JSX <svg>)
+    // Strategy precedence:
+    //   1) noZhCnJsxSvgMetadataStrategy (if explicitly set, including false)
+    //   2) fallback to noZhCnSvgMetadataStrategy (backward-compat)
+    const hasExplicitJsxMetaStrategy = Object.prototype.hasOwnProperty.call(
+      conf,
+      'noZhCnJsxSvgMetadataStrategy'
+    );
+    const jsxMetaStrategy = hasExplicitJsxMetaStrategy
+      ? noZhCnJsxSvgMetadataStrategy
+      : noZhCnSvgMetadataStrategy;
+
+    if (jsxMetaStrategy) {
+      const jsxSvgMetadataFiles = new Set();
+      allFindings.forEach((f) => {
+        if (f.type !== 'jsx-svg-metadata') return;
+        jsxSvgMetadataFiles.add(f.filePath);
+      });
+
+      jsxSvgMetadataFiles.forEach((fp) => {
+        const findings = getLatestFindingsByType(fp, 'jsx-svg-metadata');
+        if (!findings.length) return;
+        const fixed = fixJsxSvgMetadataInFile(fp, findings, jsxMetaStrategy);
+        svgFixedCount += fixed;
+      });
+      if (svgFixedCount > 0) anyFixApplied = true;
+    }
+
     // ── Single final re-scan after all fixes ──────────────────────────────
     if (anyFixApplied) {
       allFindings = [];

package/bin/scripts/nozhcnGuard.js

@@ -0,0 +1,444 @@
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = process.cwd();
+const DEFAULT_CONFIG_FILE = '.nozhcn-guard.json';
+const CJK_REGEXP = /[\u3400-\u9FFF]/g;
+
+const DEFAULT_CONFIG = {
+  include: ['.'],
+  extensions: ['.js', '.jsx', '.ts', '.tsx', '.json', '.svg', '.html', '.yml', '.yaml'],
+  scanAllFiles: true,
+  skipBinaryFiles: true,
+  exclude: [
+    '**/.git/**',
+    '**/node_modules/**',
+    '**/portalWeb/**',
+    '**/publish/**',
+    '**/helpdesk-dashboard/**',
+    '**/.kiro/**',
+    '**/memories/**',
+  ],
+  allowChinesePaths: [
+    'docs/**',
+    'locales/**',
+    'src/locales/**',
+    'portalWeb.json',
+    'NOZHCN.md',
+  ],
+  ignoreI18nDefault: false,
+  maxPrintPerFile: 20,
+  reportFile: 'nozhcn-guard-report.json',
+};
+
+function normalizePath(filePath) {
+  return filePath.split(path.sep).join('/').replace(/^\.\//, '');
+}
+
+function hasGlob(pattern) {
+  return /[*?]/.test(pattern);
+}
+
+function escapeRegExp(text) {
+  return text.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
+}
+
+function globToRegExp(glob) {
+  const normalized = normalizePath(glob);
+  if (normalized.startsWith('**/')) {
+    const rest = normalized.slice(3);
+    const restRegexp = globToRegExp(rest).source.replace(/^\^/, '').replace(/\$$/, '');
+    return new RegExp(`^(?:.*/)?${restRegexp}$`);
+  }
+
+  let source = '';
+  for (let i = 0; i < normalized.length; i += 1) {
+    const ch = normalized[i];
+    const next = normalized[i + 1];
+    if (ch === '*') {
+      if (next === '*') {
+        source += '.*';
+        i += 1;
+      } else {
+        source += '[^/]*';
+      }
+    } else if (ch === '?') {
+      source += '[^/]';
+    } else {
+      source += escapeRegExp(ch);
+    }
+  }
+
+  return new RegExp(`^${source}$`);
+}
+
+function loadConfig(configFile) {
+  const configPath = path.resolve(ROOT, configFile || DEFAULT_CONFIG_FILE);
+  if (!fs.existsSync(configPath)) {
+    return { configPath, config: { ...DEFAULT_CONFIG } };
+  }
+
+  const raw = fs.readFileSync(configPath, 'utf8');
+  const userConfig = JSON.parse(raw);
+  const config = {
+    ...DEFAULT_CONFIG,
+    ...userConfig,
+    include: Array.isArray(userConfig.include) ? userConfig.include : DEFAULT_CONFIG.include,
+    extensions: Array.isArray(userConfig.extensions) ? userConfig.extensions : DEFAULT_CONFIG.extensions,
+    exclude: Array.isArray(userConfig.exclude) ? userConfig.exclude : DEFAULT_CONFIG.exclude,
+    allowChinesePaths: Array.isArray(userConfig.allowChinesePaths)
+      ? userConfig.allowChinesePaths
+      : DEFAULT_CONFIG.allowChinesePaths,
+  };
+
+  return { configPath, config };
+}
+
+function buildMatchers(patterns) {
+  const regexps = [];
+  const literals = new Set();
+
+  for (const pattern of patterns) {
+    if (hasGlob(pattern)) {
+      regexps.push(globToRegExp(pattern));
+    } else {
+      literals.add(normalizePath(pattern));
+    }
+  }
+
+  return { regexps, literals };
+}
+
+function matchPath(relativePath, matchers) {
+  const normalized = normalizePath(relativePath);
+  if (matchers.literals.has(normalized)) {
+    return true;
+  }
+
+  for (const regexp of matchers.regexps) {
+    if (regexp.test(normalized)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function shouldScanFile(relativePath, config, excludeMatchers, allowMatchers) {
+  if (matchPath(relativePath, excludeMatchers)) {
+    return false;
+  }
+  if (matchPath(relativePath, allowMatchers)) {
+    return false;
+  }
+  if (config.scanAllFiles) {
+    return true;
+  }
+
+  const ext = path.extname(relativePath).toLowerCase();
+  return config.extensions.includes(ext);
+}
+
+function isLikelyBinaryBuffer(buffer) {
+  if (!buffer || buffer.length === 0) {
+    return false;
+  }
+
+  if (
+    (buffer.length >= 3 && buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf) ||
+    (buffer.length >= 2 && buffer[0] === 0xff && buffer[1] === 0xfe) ||
+    (buffer.length >= 2 && buffer[0] === 0xfe && buffer[1] === 0xff)
+  ) {
+    return false;
+  }
+
+  const sampleLength = Math.min(buffer.length, 8000);
+  let suspicious = 0;
+
+  for (let i = 0; i < sampleLength; i += 1) {
+    const byte = buffer[i];
+    if (byte === 0) {
+      return true;
+    }
+
+    const isTextControl = byte === 9 || byte === 10 || byte === 13;
+    const isPrintableAscii = byte >= 32 && byte <= 126;
+    const isHighByte = byte >= 128;
+    if (!isTextControl && !isPrintableAscii && !isHighByte) {
+      suspicious += 1;
+    }
+  }
+
+  return suspicious / sampleLength > 0.3;
+}
+
+function decodeUtf16LE(buffer, offset) {
+  const chars = [];
+  for (let i = offset || 0; i + 1 < buffer.length; i += 2) {
+    chars.push(String.fromCharCode(buffer[i] | (buffer[i + 1] << 8)));
+  }
+  return chars.join('');
+}
+
+function decodeUtf16BE(buffer, offset) {
+  const chars = [];
+  for (let i = offset || 0; i + 1 < buffer.length; i += 2) {
+    chars.push(String.fromCharCode((buffer[i] << 8) | buffer[i + 1]));
+  }
+  return chars.join('');
+}
+
+function looksLikeUtf16WithoutBom(buffer) {
+  const sampleLength = Math.min(buffer.length, 8000);
+  if (sampleLength < 4) {
+    return null;
+  }
+
+  let evenZero = 0;
+  let oddZero = 0;
+  let pairs = 0;
+  for (let i = 0; i + 1 < sampleLength; i += 2) {
+    if (buffer[i] === 0) {
+      evenZero += 1;
+    }
+    if (buffer[i + 1] === 0) {
+      oddZero += 1;
+    }
+    pairs += 1;
+  }
+
+  if (pairs === 0) {
+    return null;
+  }
+
+  const evenRatio = evenZero / pairs;
+  const oddRatio = oddZero / pairs;
+
+  if (oddRatio > 0.35 && oddRatio > evenRatio * 1.5) {
+    return 'utf16le';
+  }
+  if (evenRatio > 0.35 && evenRatio > oddRatio * 1.5) {
+    return 'utf16be';
+  }
+
+  return null;
+}
+
+function decodeTextBuffer(buffer) {
+  if (!buffer || buffer.length === 0) {
+    return { text: '', isBinary: false };
+  }
+
+  if (buffer.length >= 3 && buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf) {
+    return { text: buffer.toString('utf8', 3), isBinary: false };
+  }
+
+  if (buffer.length >= 2 && buffer[0] === 0xff && buffer[1] === 0xfe) {
+    return { text: decodeUtf16LE(buffer, 2), isBinary: false };
+  }
+
+  if (buffer.length >= 2 && buffer[0] === 0xfe && buffer[1] === 0xff) {
+    return { text: decodeUtf16BE(buffer, 2), isBinary: false };
+  }
+
+  const inferredUtf16 = looksLikeUtf16WithoutBom(buffer);
+  if (inferredUtf16 === 'utf16le') {
+    return { text: decodeUtf16LE(buffer, 0), isBinary: false };
+  }
+  if (inferredUtf16 === 'utf16be') {
+    return { text: decodeUtf16BE(buffer, 0), isBinary: false };
+  }
+
+  if (isLikelyBinaryBuffer(buffer)) {
+    return { text: '', isBinary: true };
+  }
+
+  return { text: buffer.toString('utf8'), isBinary: false };
+}
+
+function eraseRangeWithSpaces(input, start, end) {
+  let output = '';
+  for (let i = start; i < end; i += 1) {
+    output += input[i] === '\n' ? '\n' : ' ';
+  }
+  return output;
+}
+
+function blankI18nDefaultText(content) {
+  const dCallRegexp = /\.d\(\s*(?:'[^'\\]*(?:\\.[^'\\]*)*'|"[^"\\]*(?:\\.[^"\\]*)*"|`[\s\S]*?`)\s*\)/g;
+  let transformed = '';
+  let cursor = 0;
+  let match = dCallRegexp.exec(content);
+
+  while (match) {
+    const start = match.index;
+    const end = start + match[0].length;
+    transformed += content.slice(cursor, start);
+    transformed += eraseRangeWithSpaces(content, start, end);
+    cursor = end;
+    match = dCallRegexp.exec(content);
+  }
+
+  transformed += content.slice(cursor);
+  return transformed;
+}
+
+function collectChineseLines(content, maxPrintPerFile) {
+  const lines = content.split('\n');
+  const hits = [];
+
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    const match = line.match(CJK_REGEXP);
+    if (!match) {
+      continue;
+    }
+
+    hits.push({
+      line: i + 1,
+      sample: line.trim().slice(0, 200),
+      hitCountInLine: match.length,
+    });
+
+    if (hits.length >= maxPrintPerFile) {
+      break;
+    }
+  }
+
+  return hits;
+}
+
+function walkTarget(absTargetPath, files, excludeMatchers) {
+  if (!fs.existsSync(absTargetPath)) {
+    return;
+  }
+
+  const relativePath = normalizePath(path.relative(ROOT, absTargetPath));
+  if (relativePath && !relativePath.startsWith('..') && matchPath(relativePath, excludeMatchers)) {
+    return;
+  }
+
+  const stat = fs.statSync(absTargetPath);
+  if (stat.isFile()) {
+    files.push(absTargetPath);
+    return;
+  }
+
+  const entries = fs.readdirSync(absTargetPath);
+  for (const entry of entries) {
+    walkTarget(path.join(absTargetPath, entry), files, excludeMatchers);
+  }
+}
+
+function parseArgs(cliArgs) {
+  const args = cliArgs || process.argv.slice(2);
+  const getArgValue = (name) => {
+    const index = args.indexOf(name);
+    if (index === -1 || index === args.length - 1) {
+      return null;
+    }
+    return args[index + 1];
+  };
+
+  return {
+    reportOnly: args.includes('--report'),
+    silent: args.includes('--silent'),
+    configFile: getArgValue('--config') || DEFAULT_CONFIG_FILE,
+    reportFile: getArgValue('--report-file'),
+  };
+}
+
+function runNoZhCnGuard(cliArgs) {
+  const options = parseArgs(cliArgs);
+  const loaded = loadConfig(options.configFile);
+  const config = loaded.config;
+  const excludeMatchers = buildMatchers(config.exclude);
+  const allowMatchers = buildMatchers(config.allowChinesePaths);
+
+  const allFiles = [];
+  for (const target of config.include) {
+    walkTarget(path.resolve(ROOT, target), allFiles, excludeMatchers);
+  }
+
+  const reports = [];
+  let scannedFiles = 0;
+  let totalHitLines = 0;
+  let skippedBinaryFiles = 0;
+
+  for (const absFilePath of allFiles) {
+    const relativePath = normalizePath(path.relative(ROOT, absFilePath));
+    if (!relativePath || relativePath.startsWith('..')) {
+      continue;
+    }
+    if (!shouldScanFile(relativePath, config, excludeMatchers, allowMatchers)) {
+      continue;
+    }
+
+    const rawBuffer = fs.readFileSync(absFilePath);
+    const decoded = decodeTextBuffer(rawBuffer);
+    if (config.skipBinaryFiles && decoded.isBinary) {
+      skippedBinaryFiles += 1;
+      continue;
+    }
+
+    const scanSource = config.ignoreI18nDefault
+      ? blankI18nDefaultText(decoded.text)
+      : decoded.text;
+    const hitLines = collectChineseLines(scanSource, config.maxPrintPerFile);
+
+    scannedFiles += 1;
+    if (hitLines.length === 0) {
+      continue;
+    }
+
+    const fullHitLineCount = (scanSource.match(/[^\n]*[\u3400-\u9FFF][^\n]*/g) || []).length;
+    totalHitLines += fullHitLineCount;
+
+    reports.push({
+      file: relativePath,
+      hitLineCount: fullHitLineCount,
+      examples: hitLines,
+    });
+  }
+
+  reports.sort((a, b) => b.hitLineCount - a.hitLineCount);
+
+  const result = {
+    generatedAt: new Date().toISOString(),
+    scannedFiles,
+    problemFiles: reports.length,
+    totalHitLines,
+    skippedBinaryFiles,
+    ignoreI18nDefault: Boolean(config.ignoreI18nDefault),
+    reports,
+  };
+
+  const reportPath = path.resolve(ROOT, options.reportFile || config.reportFile);
+  fs.writeFileSync(reportPath, `${JSON.stringify(result, null, 2)}\n`, 'utf8');
+
+  if (!options.silent) {
+    console.log(`[guard] config: ${normalizePath(path.relative(ROOT, loaded.configPath))}`);
+    console.log(`[guard] scanned files: ${scannedFiles}`);
+    console.log(`[guard] files with chinese: ${reports.length}`);
+    console.log(`[guard] chinese hit lines: ${totalHitLines}`);
+    if (config.skipBinaryFiles) {
+      console.log(`[guard] skipped binary files: ${skippedBinaryFiles}`);
+    }
+    console.log(`[guard] report: ${normalizePath(path.relative(ROOT, reportPath))}`);
+
+    if (reports.length > 0) {
+      console.log('\n[guard] top files:');
+      for (const item of reports.slice(0, 20)) {
+        console.log(`  - ${item.file} (${item.hitLineCount} line hits)`);
+      }
+    }
+  }
+
+  if (options.reportOnly) {
+    process.exit(0);
+  }
+
+  process.exit(reports.length > 0 ? 1 : 0);
+}
+
+module.exports = runNoZhCnGuard;

package/bin/scripts/util/findZhCnInFile.js

@@ -8,6 +8,9 @@
  *   - jsx        : JSX text content (outside ignored components)
  *   - jsx-svg    : JSX text content INSIDE an ignored component (e.g. <svg>)
  *                  NOT auto-fixable via intl.get() — needs manual SVG handling
+ *   - jsx-svg-metadata : JSX text content inside <svg><title|desc|metadata>
+ *                        auto-fixable by nozhcn fix metadata strategy
+ *   - console   : console.* call text containing Chinese (can be auto-removed)
  *   - identifier : identifier names (rare, manual fix needed)
  *
  * Returns an array of Finding objects:
@@ -152,6 +155,17 @@ function collectCommentTokens(ast) {
   return comments;
 }
 
+function isConsoleCall(nodePath) {
+  const callee = nodePath.node && nodePath.node.callee;
+  if (!callee || callee.type !== 'MemberExpression') return false;
+  if (callee.computed) return false;
+  return callee.object && callee.object.type === 'Identifier' && callee.object.name === 'console';
+}
+
+function isInsideConsoleCall(nodePath) {
+  return !!nodePath.findParent((p) => p.isCallExpression() && isConsoleCall(p));
+}
+
 /**
  * Main export: scan a single file and return all Chinese findings.
  *
@@ -265,16 +279,65 @@ module.exports = function findZhCnInFile(filePath, opts) {
     checkTypes.includes('template') ||
     checkTypes.includes('jsx') ||
     checkTypes.includes('jsx-svg') ||
+    checkTypes.includes('jsx-svg-metadata') ||
+    checkTypes.includes('console') ||
     checkTypes.includes('identifier');
 
   if (needsAstScan) {
     traverse(ast, {
       // ── String literals ─────────────────────────────────────────────
       StringLiteral(nodePath) {
-        if (!checkTypes.includes('string')) return;
         const node = nodePath.node;
         if (!primaryRegx.test(node.value)) return;
         if (isIgnoredLine(node.loc && node.loc.start.line)) return;
+        if (checkTypes.includes('console') && isInsideConsoleCall(nodePath)) return;
+
+        // ── JSX SVG attribute detection ──────────────────────────────
+        // If this string is a JSX attribute value inside an SVG element
+        // (or other ignored component), tag it as 'jsx-svg-attr' so it
+        // can be auto-fixed via the svg attr strategy rather than being
+        // treated as a regular string literal requiring internationalisation.
+        if (nodePath.parent && nodePath.parent.type === 'JSXAttribute') {
+          let insideIgnored = false;
+          nodePath.findParent((p) => {
+            if (!p.isJSXElement()) return false;
+            const openingName = p.node.openingElement && p.node.openingElement.name;
+            if (!openingName) return false;
+            const componentName =
+              openingName.name ||
+              (openingName.namespace && openingName.namespace.name) ||
+              '';
+            if (ignoreComponents.includes(componentName)) {
+              insideIgnored = true;
+              return true;
+            }
+            return false;
+          });
+
+          if (insideIgnored) {
+            if (checkTypes.includes('string') || checkTypes.includes('jsx-svg-attr')) {
+              const attrName =
+                nodePath.parent.name && nodePath.parent.name.name
+                  ? nodePath.parent.name.name
+                  : '';
+              findings.push({
+                filePath,
+                type: 'jsx-svg-attr',
+                line: node.loc && node.loc.start.line,
+                col: node.loc && node.loc.start.column,
+                content: node.value,
+                attrName,
+                // Byte offsets (includes quote chars) — used by fixJsxSvgAttrInFile
+                start: node.start,
+                end: node.end,
+              });
+            }
+            return; // do NOT also report as 'string'
+          }
+        }
+
+        // ── Normal string literal ─────────────────────────────────────
+        if (!checkTypes.includes('string')) return;
         if (
           ignoreI18nDefault &&
           isI18nDefaultValue(nodePath, i18nMethod, i18nDefaultFunctionKey, i18nObject)
@@ -300,6 +363,7 @@ module.exports = function findZhCnInFile(filePath, opts) {
         ) {
           return;
         }
+        if (checkTypes.includes('console') && isInsideConsoleCall(nodePath)) return;
         nodePath.node.quasis.forEach((quasi) => {
           if (!primaryRegx.test(quasi.value.raw)) return;
           if (isIgnoredLine(quasi.loc && quasi.loc.start.line)) return;
@@ -313,9 +377,37 @@ module.exports = function findZhCnInFile(filePath, opts) {
         });
       },
 
+      CallExpression(nodePath) {
+        if (!checkTypes.includes('console')) return;
+        if (!isConsoleCall(nodePath)) return;
+        const node = nodePath.node;
+        const line = node.loc && node.loc.start.line;
+        if (isIgnoredLine(line)) return;
+        const rawCall = source.slice(node.start, node.end);
+        if (!primaryRegx.test(rawCall)) return;
+
+        const stmt = nodePath.parentPath && nodePath.parentPath.isExpressionStatement()
+          ? nodePath.parentPath.node
+          : null;
+
+        findings.push({
+          filePath,
+          type: 'console',
+          line: (stmt && stmt.loc && stmt.loc.start.line) || line,
+          col: (stmt && stmt.loc && stmt.loc.start.column) || (node.loc && node.loc.start.column),
+          content: rawCall,
+          stmtStart: stmt && typeof stmt.start === 'number' ? stmt.start : null,
+          stmtEnd: stmt && typeof stmt.end === 'number' ? stmt.end : null,
+        });
+      },
+
       // ── JSX text ────────────────────────────────────────────────────
       JSXText(nodePath) {
-        if (!checkTypes.includes('jsx') && !checkTypes.includes('jsx-svg')) return;
+        const wantsAnyJsx =
+          checkTypes.includes('jsx') ||
+          checkTypes.includes('jsx-svg') ||
+          checkTypes.includes('jsx-svg-metadata');
+        if (!wantsAnyJsx) return;
         const node = nodePath.node;
         const text = node.value.trim();
         if (!text || !primaryRegx.test(text)) return;
@@ -325,6 +417,8 @@ module.exports = function findZhCnInFile(filePath, opts) {
         // component (e.g. <svg>, <style>).  If so, tag as 'jsx-svg' so
         // the caller knows this cannot be fixed via intl.get().
         let insideIgnored = false;
+        let insideSvgMetadata = false;
+        let metadataElement = null;
         nodePath.findParent((p) => {
           if (!p.isJSXElement()) return false;
           const openingName = p.node.openingElement && p.node.openingElement.name;
@@ -334,6 +428,12 @@ module.exports = function findZhCnInFile(filePath, opts) {
             openingName.name ||
             (openingName.namespace && openingName.namespace.name) ||
             '';
+
+          if (!insideSvgMetadata && ['title', 'desc', 'metadata'].includes(componentName)) {
+            insideSvgMetadata = true;
+            metadataElement = p.node;
+          }
+
           if (ignoreComponents.includes(componentName)) {
             insideIgnored = true;
             return true; // stop traversal
@@ -341,16 +441,37 @@ module.exports = function findZhCnInFile(filePath, opts) {
           return false;
         });
 
-        const type = insideIgnored ? 'jsx-svg' : 'jsx';
-        if (!checkTypes.includes(type)) return;
+        let type = 'jsx';
+        if (insideIgnored && insideSvgMetadata) {
+          type = 'jsx-svg-metadata';
+          if (!(checkTypes.includes('jsx') || checkTypes.includes('jsx-svg') || checkTypes.includes('jsx-svg-metadata'))) {
+            return;
+          }
+        } else if (insideIgnored) {
+          type = 'jsx-svg';
+          if (!checkTypes.includes('jsx-svg')) return;
+        } else {
+          if (!checkTypes.includes('jsx')) return;
+        }
 
-        findings.push({
+        const finding = {
           filePath,
           type,
           line: node.loc && node.loc.start.line,
           col: node.loc && node.loc.start.column,
           content: text,
-        });
+        };
+
+        if (type === 'jsx-svg-metadata') {
+          finding.start = node.start;
+          finding.end = node.end;
+          if (metadataElement) {
+            finding.metaElementStart = metadataElement.start;
+            finding.metaElementEnd = metadataElement.end;
+          }
+        }
+
+        findings.push(finding);
       },
 
       // ── Identifiers (variable / function / class names) ─────────────

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chaoswise/intl",
-  "version": "3.1.2",
+  "version": "3.1.3",
   "author": "cloudwiser",
   "description": "intl",
   "main": "lib/index.js",