@chaoswise/intl 2.1.10 → 3.1.0

package/bin/scripts/util/fixZhCnInFile.js

@@ -0,0 +1,217 @@
+/**
+ * fixZhCnInFile.js
+ *
+ * Fixes Chinese characters found in COMMENT nodes by patching the raw source
+ * using byte-offset positions from AST tokens.
+ *
+ * Strategy options:
+ *   'clean'  - Remove only Chinese characters from comment value.
+ *              If the cleaned value is whitespace-only, remove the entire
+ *              comment token (including delimiters // or /* ... *\/).
+ *   'remove' - Remove the entire comment token unconditionally.
+ *
+ * Important: This function operates on raw source bytes:
+ *   - It sorts findings by `start` in descending order so that later
+ *     replacements do not invalidate earlier offsets.
+ *   - Only `comment` type findings (which carry `start` and `end` byte
+ *     offsets) are accepted.
+ *
+ * Returns the number of comment tokens patched (0 if nothing was modified).
+ */
+
+const fs = require('fs');
+const log = require('./log');
+
+// Chinese character range, same as primaryRegx default
+const ZH_REGEX = /[\u4e00-\u9fa5]/g;
+
+/**
+ * Compute the replacement string for a single comment token.
+ *
+ * In Babel AST (with tokens:true):
+ *   CommentLine  : value = text after '//'   (no newline)
+ *   CommentBlock : value = text between '/*' and '*\/'
+ *
+ * source.slice(start, end) gives the full token including delimiters.
+ *
+ * @param {{ type: string, value: string, start: number, end: number }} comment
+ * @param {'clean'|'remove'} strategy
+ * @returns {string|null}  null means "delete the token entirely"
+ */
+function computeReplacement(comment, strategy) {
+  const { type, value } = comment;
+
+  if (strategy === 'remove') {
+    return null;
+  }
+
+  // strategy === 'clean': strip Chinese characters from value
+  const cleanedValue = value.replace(ZH_REGEX, '');
+
+  if (!cleanedValue.trim()) {
+    // Comment content is now empty → remove the token
+    return null;
+  }
+
+  if (type === 'CommentLine') {
+    return `//${cleanedValue}`;
+  }
+  // CommentBlock
+  return `/*${cleanedValue}*/`;
+}
+
+/**
+ * After removing a comment token, if the rest of the line is blank
+ * (only whitespace between the last newline and the token start),
+ * also remove the trailing newline so we don't leave empty lines.
+ *
+ * Special case – JSX expression-container comments  { /‌* ... *‌/ }  (where
+ * the comment is the sole content of a JSX expression): the surrounding
+ * { } braces must also be removed, otherwise an orphan {} expression is left.
+ * We detect this by checking whether the characters directly flanking the
+ * comment token (past optional spaces) are { and }, and if so extend the
+ * deletion range to cover them as well.
+ *
+ * @param {string} source
+ * @param {number} tokenStart  - char index of the comment token start
+ * @param {number} tokenEnd    - char index just past the comment token end
+ * @returns {{ patchStart: number, patchEnd: number }}
+ */
+function calcDeletionRange(source, tokenStart, tokenEnd) {
+  // ── Determine the effective deletion boundaries ───────────────────────────
+  // For JSX expression-container comments `{ /* ... */ }`, we want to delete
+  // the wrapping braces as well, otherwise we leave an orphan `{}` expression.
+  let effectiveStart = tokenStart;
+  let effectiveEnd = tokenEnd;
+
+  // Walk backwards past optional spaces to find a potential `{`
+  let braceOpen = tokenStart - 1;
+  while (braceOpen >= 0 && source[braceOpen] === ' ') braceOpen--;
+
+  // Walk forwards past optional spaces to find a potential `}`
+  let braceClose = tokenEnd;
+  while (braceClose < source.length && source[braceClose] === ' ') braceClose++;
+
+  if (
+    braceOpen >= 0 && source[braceOpen] === '{' &&
+    braceClose < source.length && source[braceClose] === '}'
+  ) {
+    // The comment is the sole content of a JSX `{...}` expression — include the braces.
+    effectiveStart = braceOpen;
+    effectiveEnd = braceClose + 1;
+  }
+
+  // ── Guard: if tokenEnd somehow overshot a newline, clamp back ────────────
+  // Babel's comment.end should never include the trailing \n of a CommentLine,
+  // but be defensive: if the character just before effectiveEnd is a newline,
+  // we are already at the start of the next line — step back to the \n itself
+  // so the lineEnd walk below stays on the correct line.
+  let adjustedEnd = effectiveEnd;
+  if (adjustedEnd > effectiveStart && adjustedEnd > 0 &&
+      source[adjustedEnd - 1] === '\n' &&
+      (adjustedEnd >= source.length || source[adjustedEnd] !== '\n')) {
+    adjustedEnd--;
+  }
+
+  // ── Decide whether to remove the whole line or just the token ────────────
+  let lineStart = effectiveStart;
+  while (lineStart > 0 && source[lineStart - 1] !== '\n') {
+    lineStart--;
+  }
+  const before = source.slice(lineStart, effectiveStart);
+  const onlyWhitespaceBefore = /^\s*$/.test(before);
+
+  let lineEnd = adjustedEnd;
+  while (lineEnd < source.length && source[lineEnd] !== '\n') {
+    lineEnd++;
+  }
+  const after = source.slice(adjustedEnd, lineEnd);
+  const onlyWhitespaceAfter = /^\s*$/.test(after);
+
+  if (onlyWhitespaceBefore && onlyWhitespaceAfter) {
+    // Remove the entire line including the trailing newline (if present)
+    const end = lineEnd < source.length ? lineEnd + 1 : lineEnd;
+    return { patchStart: lineStart, patchEnd: end };
+  }
+
+  // Comment is inline on a code line — just remove the effective range
+  return { patchStart: effectiveStart, patchEnd: effectiveEnd };
+}
+
+/**
+ * Fix all comment findings in a single file.
+ *
+ * @param {string}   filePath  - absolute file path
+ * @param {Finding[]} findings - array of { type:'comment', start, end, commentType, ... }
+ * @param {'clean'|'remove'} strategy
+ * @returns {number} count of comment findings actually patched (0 if none)
+ */
+module.exports = function fixZhCnInFile(filePath, findings, strategy = 'clean') {
+  // Filter to comment-type findings that have byte offsets
+  const commentFindings = findings.filter(
+    (f) => f.type === 'comment' && typeof f.start === 'number' && typeof f.end === 'number'
+  );
+
+  if (!commentFindings.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;
+  }
+
+  // Sort descending by start so we patch from the end backwards,
+  // preserving the validity of earlier byte offsets.
+  const sorted = [...commentFindings].sort((a, b) => b.start - a.start);
+
+  let patchedCount = 0;
+
+  for (const finding of sorted) {
+    const { start, end, commentType } = finding;
+
+    // Reconstruct the original comment object expected by computeReplacement
+    const originalSource = source.slice(start, end);
+
+    // Extract the raw value (without delimiters) from the source token
+    // so that computeReplacement works even if the finding.content is
+    // already formatted with delimiters.
+    let rawValue;
+    if (commentType === 'CommentLine') {
+      // source token = '//' + value
+      rawValue = originalSource.startsWith('//') ? originalSource.slice(2) : originalSource;
+    } else {
+      // source token = '/*' + value + '*/'
+      if (originalSource.startsWith('/*') && originalSource.endsWith('*/')) {
+        rawValue = originalSource.slice(2, -2);
+      } else {
+        rawValue = originalSource;
+      }
+    }
+
+    const pseudoComment = { type: commentType, value: rawValue, start, end };
+    const replacement = computeReplacement(pseudoComment, strategy);
+
+    if (replacement === null) {
+      // Delete the token (and possibly the whole line if it becomes empty)
+      const { patchStart, patchEnd } = calcDeletionRange(source, start, end);
+      source = source.slice(0, patchStart) + source.slice(patchEnd);
+    } else {
+      source = source.slice(0, start) + replacement + source.slice(end);
+    }
+
+    patchedCount++;
+  }
+
+  if (patchedCount > 0) {
+    try {
+      fs.writeFileSync(filePath, source, { encoding: 'utf-8' });
+    } catch (err) {
+      log.error(`[nozhcn] Cannot write file: ${filePath} — ${err.message}`);
+      return 0;
+    }
+  }
+
+  return patchedCount;
+};

package/bin/scripts/util/fixZhCnInSvgFile.js

@@ -0,0 +1,206 @@
+/**
+ * fixZhCnInSvgFile.js
+ *
+ * Auto-fixes Chinese characters in standalone SVG files.
+ *
+ * Fixable types (from findZhCnInSvgFile.js):
+ *   svg-comment   ─ auto-fixable via comment clean/remove strategy
+ *   svg-metadata  ─ auto-fixable: remove element or empty its content
+ *
+ * Conditionally fixable types:
+ *   svg-attr      ─ attribute values (e.g. id="矩形", id="编组-11")
+ *                   typically design-tool layer-name artifacts; fixable
+ *                   when attrStrategy is set to 'clean' or 'remove'
+ *
+ * Non-fixable types (reported but not touched):
+ *   svg-text      ─ visible rendered text, requires design/i18n decision
+ *
+ * Strategies
+ * ──────────────────────────────────────────────────────────────────────
+ * commentStrategy ('clean' | 'remove')
+ *   'clean'  : Remove only Chinese characters from the comment value.
+ *              If the cleaned value is whitespace-only, delete the comment.
+ *   'remove' : Delete the entire comment unconditionally.
+ *
+ * metadataStrategy ('remove' | 'empty')
+ *   'remove' : Delete the entire <title>/<desc>/<metadata> element.
+ *   'empty'  : Keep the element but empty its contents:
+ *              <title>搜索</title>  →  <title></title>
+ *
+ * attrStrategy ('clean' | 'remove' | false)
+ *   'clean'  : Strip Chinese (and CJK punctuation) from attribute values.
+ *              If the cleaned value is empty, remove the attribute entirely.
+ *              Renamed id attributes update internal url(#…) / href refs.
+ *   'remove' : Remove the entire attribute.
+ *   false    : Do not auto-fix attributes (default, backward-compat).
+ *
+ * Returns { fixed: number }  (count of SVG elements/comments fixed)
+ */
+
+const fs = require('fs');
+const log = require('./log');
+
+const ZH_REGEX = /[\u4e00-\u9fa5]/g;
+const ZH_TEST = /[\u4e00-\u9fa5]/;
+// Chinese chars + CJK symbols/punctuation + fullwidth forms (design-tool junk)
+const ZH_CLEAN_REGEX = /[\u4e00-\u9fa5\u3000-\u303f\uff00-\uffef]/g;
+
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Apply attribute fix strategy to the full source string.
+ * Handles id renames with internal SVG reference updates.
+ */
+function fixAttrs(source, strategy) {
+  const idRenames = new Map(); // oldValue → newValue | null
+
+  // Pass 1: Process ONLY id attributes with Chinese values
+  source = source.replace(
+    /(\s)(id)=(["'])([^"']*[\u4e00-\u9fa5][^"']*)\3/g,
+    (match, ws, attr, quote, value) => {
+      if (strategy === 'remove') {
+        idRenames.set(value, null);
+        return '';
+      }
+      // 'clean': strip Chinese + CJK punctuation
+      const cleaned = value.replace(ZH_CLEAN_REGEX, '').trim();
+      if (!cleaned) {
+        idRenames.set(value, null);
+        return '';
+      }
+      idRenames.set(value, cleaned);
+      return `${ws}id=${quote}${cleaned}${quote}`;
+    }
+  );
+
+  // Pass 2: Update internal references for renamed / removed ids
+  idRenames.forEach((newId, oldId) => {
+    const esc = escapeRegExp(oldId);
+    if (newId) {
+      source = source.replace(new RegExp(`url\\(#${esc}\\)`, 'g'), `url(#${newId})`);
+      source = source.replace(
+        new RegExp(`(xlink:href|href)=(["'])#${esc}\\2`, 'g'),
+        `$1=$2#${newId}$2`
+      );
+    } else {
+      // id was removed — neutralise dangling url() references
+      source = source.replace(new RegExp(`url\\(#${esc}\\)`, 'g'), 'none');
+    }
+  });
+
+  // Pass 3: Process remaining (non-id) attributes with Chinese values
+  source = source.replace(
+    /(\s)([\w:_-]+)=(["'])([^"']*[\u4e00-\u9fa5][^"']*)\3/g,
+    (match, ws, attr, quote, value) => {
+      if (attr === 'id') return match; // already handled
+      if (strategy === 'remove') return '';
+      const cleaned = value.replace(ZH_CLEAN_REGEX, '').trim();
+      if (!cleaned) return '';
+      return `${ws}${attr}=${quote}${cleaned}${quote}`;
+    }
+  );
+
+  return source;
+}
+
+/**
+ * Apply comment fix strategy to the full source string.
+ */
+function fixComments(source, strategy) {
+  return source.replace(/<!--([\s\S]*?)-->/g, (match, content) => {
+    if (!ZH_TEST.test(content)) return match;
+    if (strategy === 'remove') return '';
+    const cleaned = content.replace(ZH_REGEX, '');
+    if (!cleaned.trim()) return '';
+    return `<!--${cleaned}-->`;
+  });
+}
+
+/**
+ * Apply metadata element fix strategy to the full source string.
+ * Handles <title>, <desc>, <metadata> (case-insensitive, with attributes).
+ */
+function fixMetadata(source, strategy) {
+  return source.replace(/<(title|desc|metadata)(\s[^>]*)?>[\s\S]*?<\/\1>/gi, (match, tag, attrs) => {
+    if (!ZH_TEST.test(match)) return match;
+    if (strategy === 'remove') return '';
+    // 'empty': keep the opening/closing tags, remove content
+    const openTag = attrs ? `<${tag}${attrs}>` : `<${tag}>`;
+    return `${openTag}</${tag}>`;
+  });
+}
+
+/**
+ * Fix Chinese in SVG comments and metadata elements.
+ *
+ * @param {string}   filePath         - absolute path to the .svg file
+ * @param {Finding[]} findings        - from findZhCnInSvgFile (all types)
+ * @param {object}   opts
+ *   - commentStrategy   'clean' | 'remove'   (default: 'clean')
+ *   - metadataStrategy  'remove' | 'empty'   (default: 'remove')
+ *   - attrStrategy      'clean' | 'remove' | false  (default: false)
+ * @returns {{ fixed: number }}
+ */
+module.exports = function fixZhCnInSvgFile(filePath, findings, opts) {
+  const {
+    commentStrategy = 'clean',
+    metadataStrategy = 'remove',
+    attrStrategy = false,
+  } = opts || {};
+
+  const hasFixableFindings = findings.some(
+    (f) => f.type === 'svg-comment' || f.type === 'svg-metadata' ||
+           (f.type === 'svg-attr' && attrStrategy)
+  );
+  if (!hasFixableFindings) return { fixed: 0 };
+
+  let source;
+  try {
+    source = fs.readFileSync(filePath, 'utf8');
+  } catch (err) {
+    log.error(`[nozhcn] Cannot read SVG file: ${filePath} — ${err.message}`);
+    return { fixed: 0 };
+  }
+
+  const before = source;
+
+  // Fix comments
+  const hasCommentFindings = findings.some((f) => f.type === 'svg-comment');
+  if (hasCommentFindings) {
+    source = fixComments(source, commentStrategy);
+  }
+
+  // Fix metadata elements
+  const hasMetadataFindings = findings.some((f) => f.type === 'svg-metadata');
+  if (hasMetadataFindings) {
+    source = fixMetadata(source, metadataStrategy);
+  }
+
+  // Fix attributes (opt-in)
+  const hasAttrFindings = findings.some((f) => f.type === 'svg-attr');
+  if (hasAttrFindings && attrStrategy) {
+    source = fixAttrs(source, attrStrategy);
+  }
+
+  if (source === before) return { fixed: 0 };
+
+  // Clean up blank lines left behind by removed elements/comments
+  source = source.replace(/\n[ \t]*\n/g, '\n');
+
+  // Count how many fixable findings were addressed
+  const fixed = findings.filter(
+    (f) => f.type === 'svg-comment' || f.type === 'svg-metadata' ||
+           (f.type === 'svg-attr' && attrStrategy)
+  ).length;
+
+  try {
+    fs.writeFileSync(filePath, source, { encoding: 'utf-8' });
+  } catch (err) {
+    log.error(`[nozhcn] Cannot write SVG file: ${filePath} — ${err.message}`);
+    return { fixed: 0 };
+  }
+
+  return { fixed };
+};

package/bin/scripts/util/makeVisitorCollect.js

@@ -159,19 +159,27 @@ module.exports = function (
   }
 
   // XXX: [TRICKY] 防止中文转码为 unicode
+  // 注意：recast 打印 StringLiteral 时直接使用 node.value，而不是 extra.raw
+  // 所以需要直接创建值为 id 的字符串节点，同时保留原始中文在 extra 中
   function hackValue(value, id) {
-    if (id) hacked[id] = true;
+    // 如果 id 未定义，使用 value 作为回退（用于第一次收集阶段）
+    const actualId = id || value;
+    if (actualId) hacked[actualId] = true;
 
     // 字符串默认是单引号，如果模板字符串中出现单引号，需要转义，把 ' 换成 \'
     // 就算用户自定配置字符串为双引号，也没事，默认会转义双引号，但是默认不会处理单引号，所以自己手动处理
-    if (/\'/.test(id)) {
-      id = id.replace(/\'/g, "\\'");
+    let rawValue = actualId;
+    if (/\'/.test(actualId)) {
+      rawValue = actualId.replace(/\'/g, "\\'");
     }
 
-    return Object.assign(t.StringLiteral(value), {
+    // 直接创建值为 actualId 的字符串节点，recast 会使用 node.value 作为输出
+    return Object.assign(t.StringLiteral(actualId), {
       extra: {
-        raw: `'${id}'`, // id
-        rawValue: value, // word
+        raw: `'${rawValue}'`,
+        rawValue: actualId,
+        // 保存原始中文，用于后续需要时使用
+        originalValue: value,
       },
     });
   }

package/bin/scripts/util/transformAst.js

@@ -1,8 +1,7 @@
 const fs = require("fs");
 const path = require("path");
-const prettier = require("prettier");
+const recast = require("recast");
 const babel = require("@babel/core");
-const generate = require("@babel/generator").default;
 const traverse = require("@babel/traverse").default;
 const pluginSyntaxJSX = require("@babel/plugin-syntax-jsx");
 const pluginSyntaxProposalOptionalChaining = require("@babel/plugin-proposal-optional-chaining");
@@ -23,7 +22,9 @@ const log = require("./log");
 // 获取文件中需要忽略转化通用国际化API规范的所有行号
 function getIgnoreLines(ast) {
   const ignoreBlocks = [];
-  for (const comment of ast.comments) {
+
+  // 收集注释的辅助函数
+  function processComment(comment) {
     const { type, value, loc } = comment;
     const last = ignoreBlocks.length - 1;
 
@@ -50,9 +51,25 @@ function getIgnoreLines(ast) {
     }
   }
 
+  // 从 ast.comments 获取注释（Babel 格式）
+  if (ast.comments && Array.isArray(ast.comments)) {
+    for (const comment of ast.comments) {
+      processComment(comment);
+    }
+  }
+
+  // 从 ast.tokens 获取注释（recast 格式）
+  if (ast.tokens && Array.isArray(ast.tokens)) {
+    for (const token of ast.tokens) {
+      if (token.type === "CommentLine" || token.type === "CommentBlock") {
+        processComment(token);
+      }
+    }
+  }
+
   // 如果缺少 disable-enable，直接作用到最后一行
   const len = ignoreBlocks.length;
-  if (len > 0 && !ignoreBlocks[len - 1].end) {
+  if (len > 0 && !ignoreBlocks[len - 1].end && ast.loc && ast.loc.end) {
     ignoreBlocks[len - 1].end = ast.loc.end.line;
   }
 
@@ -89,6 +106,7 @@ module.exports = function (type, files = [], conf = {}, replaceWords) {
     sourceType: "module",
     ast: true,
     configFile: false,
+    parserOpts: { tokens: true },
     presets: [
       ...babelPresets,
       [presetTypescript, { isTSX: true, allExtensions: true }],
@@ -116,14 +134,14 @@ module.exports = function (type, files = [], conf = {}, replaceWords) {
       specialFileReg.some((item) => {
         if (typeof item === "string") {
           return item === filePath;
-        } else {
+        } else if (item instanceof RegExp) {
           return item.test(filePath);
         }
+        return false;
       })
     ) {
       file.special = true;
     }
-    const isTSX = [".ts", ".tsx"].includes(path.extname(filePath));
 
     const r = {
       allWords,
@@ -137,8 +155,17 @@ module.exports = function (type, files = [], conf = {}, replaceWords) {
     const sourceCode = fs.readFileSync(filePath, "utf8");
 
     let ast;
+    let recastAst;
     try {
-      ast = babel.parseSync(sourceCode, transformOptions);
+      // 使用 recast 解析，内部委托给 babel，保留原始格式信息
+      recastAst = recast.parse(sourceCode, {
+        parser: {
+          parse(source) {
+            return babel.parseSync(source, transformOptions);
+          },
+        },
+      });
+      ast = recastAst.program;
     } catch (error) {
       replaceWords &&
         log.error(`文件解析出错：${file.filePath}
@@ -146,7 +173,7 @@ module.exports = function (type, files = [], conf = {}, replaceWords) {
       return;
     }
 
-    opts.ignoreLines = getIgnoreLines(ast);
+    opts.ignoreLines = getIgnoreLines(recastAst);
 
     let makeVisitor = makeVisitorCollect;
     if (type === "update") {
@@ -155,7 +182,7 @@ module.exports = function (type, files = [], conf = {}, replaceWords) {
 
     try {
       const visitor = makeVisitor(opts, r, file);
-      traverse(ast, visitor);
+      traverse(recastAst, visitor);
     } catch (e) {
       replaceWords &&
         log.error(`文件解析出错：${file.filePath}
@@ -167,11 +194,8 @@ module.exports = function (type, files = [], conf = {}, replaceWords) {
     // 在只需要提取中文词条的情况下不传入replaceWords
     if (!replaceWords) return;
 
-    // https://stackoverflow.com/a/55478641
-    let { code } = generate(ast, {
-      retainLines: true,
-      decoratorsBeforeExport: true,
-    });
+    // 使用 recast 输出代码，仅重新打印被修改的 AST 节点，保留原始格式
+    let code = recast.print(recastAst).code;
 
     if (!r.hasTouch) {
       code = sourceCode;
@@ -184,13 +208,7 @@ module.exports = function (type, files = [], conf = {}, replaceWords) {
       code = `${importCode}\n${code}`;
     }
 
-    // 自定义格式化代码
     if (r.hasTouch) {
-      if (conf.prettier) {
-        const parser = isTSX ? "typescript" : "babel";
-        code = prettier.format(code, { ...conf.prettier, parser });
-      }
-
       const target = file.currentOutput
         ? filePath.replace(file.currentEntry, file.currentOutput)
         : filePath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chaoswise/intl",
-  "version": "2.1.10",
+  "version": "3.1.0",
   "author": "cloudwiser",
   "description": "intl",
   "main": "lib/index.js",
@@ -24,7 +24,8 @@
   },
   "scripts": {
     "init": "npm i",
-    "build": "gulp build --gulpfile ./scripts/gulpfile.js"
+    "build": "gulp build --gulpfile ./scripts/gulpfile.js",
+    "test:nozhcn": "node --test --test-reporter=spec '__tests__/nozhcn/*.test.js'"
   },
   "keywords": [
     "intl"
@@ -77,6 +78,7 @@
     "object-keys": "^1.0.11",
     "prettier": "^2.8.1",
     "react-intl-universal": "^2.6.11",
+    "recast": "^0.23.11",
     "uuid": "^9.0.0",
     "xlsx": "^0.18.5"
   },