@chaoswise/intl 3.0.0 → 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chaoswise/intl",
-  "version": "3.0.0",
+  "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"