@chaoswise/intl 3.1.1 → 3.1.3

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) ─────────────