ai-localize-scanner 2.0.5 → 2.0.7

package/dist/index.mjs

@@ -4,6 +4,7 @@ import traverse from "@babel/traverse";
 import * as t from "@babel/types";
 import {
   isHumanReadableText,
+  isCssClassString,
   normalizeText,
   TEXT_ATTRIBUTE_NAMES,
   generateKeyByStyle
@@ -14,9 +15,239 @@ var BUILTIN_TRANSLATION_IMPORT_SOURCES = /* @__PURE__ */ new Set([
   "vue-i18n",
   "@ngx-translate/core"
 ]);
+var NON_TRANSLATABLE_ATTR_NAMES = /* @__PURE__ */ new Set([
+  "classname",
+  "class",
+  "id",
+  "name",
+  "key",
+  "ref",
+  "type",
+  "method",
+  "action",
+  "enctype",
+  "href",
+  "src",
+  "srcset",
+  "action",
+  "to",
+  "as",
+  "path",
+  "url",
+  "rel",
+  "target",
+  "referrerpolicy",
+  "crossorigin",
+  "fetchpriority",
+  "loading",
+  "decoding",
+  "sizes",
+  "media",
+  "role",
+  "tabindex",
+  "autocomplete",
+  "inputmode",
+  "dir",
+  "lang",
+  "charset",
+  "for",
+  "htmlfor",
+  "htmlFor",
+  "accept",
+  "capture",
+  "pattern",
+  "autocorrect",
+  "autocapitalize",
+  "spellcheck",
+  "style",
+  "css",
+  "data-testid",
+  "data-cy",
+  "data-test",
+  "data-id",
+  "variant",
+  "color",
+  "size",
+  "shape",
+  "align",
+  "valign",
+  "justify",
+  "orientation",
+  "direction",
+  "placement",
+  "position",
+  "icon",
+  "iconname",
+  "lefticon",
+  "righticon"
+]);
+var NON_TRANSLATABLE_PROP_KEYS = /* @__PURE__ */ new Set([
+  // HTML/JSX structural
+  "className",
+  "class",
+  "id",
+  "name",
+  "key",
+  "ref",
+  "type",
+  "method",
+  "action",
+  "href",
+  "src",
+  "rel",
+  "target",
+  "role",
+  "style",
+  "css",
+  "to",
+  "as",
+  "path",
+  "url",
+  "link",
+  "icon",
+  "variant",
+  "color",
+  "size",
+  // CSS-in-JS style properties
+  "fontFamily",
+  "fontWeight",
+  "fontStyle",
+  "fontVariant",
+  "fontSize",
+  "fontStretch",
+  "color",
+  "backgroundColor",
+  "borderColor",
+  "outlineColor",
+  "textDecorationColor",
+  "display",
+  "position",
+  "visibility",
+  "overflow",
+  "overflowX",
+  "overflowY",
+  "cursor",
+  "pointerEvents",
+  "userSelect",
+  "appearance",
+  "resize",
+  "textAlign",
+  "verticalAlign",
+  "textDecoration",
+  "textTransform",
+  "textOverflow",
+  "whiteSpace",
+  "wordBreak",
+  "wordWrap",
+  "overflowWrap",
+  "lineBreak",
+  "hyphens",
+  "flexDirection",
+  "flexWrap",
+  "alignItems",
+  "alignContent",
+  "alignSelf",
+  "justifyContent",
+  "justifyItems",
+  "justifySelf",
+  "flexFlow",
+  "gridAutoFlow",
+  "gridAutoColumns",
+  "gridAutoRows",
+  "float",
+  "clear",
+  "objectFit",
+  "objectPosition",
+  "listStyle",
+  "listStyleType",
+  "borderStyle",
+  "outlineStyle",
+  "backgroundRepeat",
+  "backgroundAttachment",
+  "backgroundPosition",
+  "backgroundSize",
+  "backgroundBlendMode",
+  "mixBlendMode",
+  "isolation",
+  "boxSizing",
+  "tableLayout",
+  "captionSide",
+  "borderCollapse",
+  "imageRendering",
+  "shapeOutside",
+  "shapeBox",
+  "writingMode",
+  "direction",
+  "speak",
+  "contentVisibility",
+  // Animation / transition
+  "animationName",
+  "animationTimingFunction",
+  "animationFillMode",
+  "animationDirection",
+  "animationPlayState",
+  "transitionTimingFunction",
+  "transitionProperty",
+  "transformOrigin",
+  "transformBox",
+  "transformStyle",
+  // Event handler patterns
+  "onChange",
+  "onClick",
+  "onSubmit",
+  "onFocus",
+  "onBlur",
+  "onKeyDown",
+  "onKeyUp",
+  "onKeyPress",
+  "onMouseEnter",
+  "onMouseLeave",
+  "onMouseOver",
+  "onMouseOut",
+  "onMouseDown",
+  "onMouseUp",
+  "onDragStart",
+  "onDrop",
+  "onTouchStart",
+  "onTouchEnd",
+  "onTouchMove",
+  "onScroll",
+  "onResize",
+  "onLoad",
+  "onError",
+  "onAbort",
+  "onContextMenu",
+  "onDoubleClick",
+  "onSelect",
+  "onInput",
+  "onPaste",
+  "onCopy",
+  "onCut",
+  "onWheel"
+]);
+var CSS_UTILITY_FN_NAMES = /* @__PURE__ */ new Set([
+  "clsx",
+  "cx",
+  "classnames",
+  "classNames",
+  "cn",
+  "cc",
+  "twMerge",
+  "twJoin",
+  "tw",
+  "cva",
+  "ctl",
+  "classes",
+  "makeClasses",
+  "styled",
+  // styled-components / @emotion tag
+  "css"
+  // @emotion/css or linaria
+]);
 var AstScanner = class {
   options;
   detectedTexts = [];
+  compiledIgnorePatterns = [];
   /** Identifiers whose call/bracket expressions contain already-translated strings. */
   translationFunctionNames;
   /**
@@ -27,6 +258,13 @@ var AstScanner = class {
   importSourceMatchers;
   constructor(options) {
     this.options = options;
+    this.compiledIgnorePatterns = (options.ignoreTextPatterns ?? []).flatMap((p) => {
+      try {
+        return [new RegExp(p)];
+      } catch {
+        return [];
+      }
+    });
     this.translationFunctionNames = /* @__PURE__ */ new Set(["t", "$t", "i18n", "translate"]);
     this.importSourceMatchers = Array.from(BUILTIN_TRANSLATION_IMPORT_SOURCES).map(
       (pkg) => (src) => src === pkg
@@ -67,9 +305,10 @@ var AstScanner = class {
     }
     this.collectTranslationImports(ast);
     traverse(ast, {
+      // ── JSX text nodes: <h1>Welcome</h1> ───────────────────────────────────
       JSXText: (nodePath) => {
         const text = normalizeText(nodePath.node.value);
-        if (!isHumanReadableText(text)) return;
+        if (!this.isTranslatableText(text)) return;
         if (this.isInsideTranslationCall(nodePath)) return;
         this.addDetected(
           text,
@@ -79,13 +318,15 @@ var AstScanner = class {
           "JSXText"
         );
       },
+      // ── JSX text-content attributes: placeholder="...", alt="..." ──────────
       JSXAttribute: (nodePath) => {
         const attrName = t.isJSXIdentifier(nodePath.node.name) ? nodePath.node.name.name : "";
         if (!TEXT_ATTRIBUTE_NAMES.has(attrName.toLowerCase())) return;
+        if (NON_TRANSLATABLE_ATTR_NAMES.has(attrName.toLowerCase())) return;
         const valueNode = nodePath.node.value;
         if (!t.isStringLiteral(valueNode)) return;
         const text = normalizeText(valueNode.value);
-        if (!isHumanReadableText(text)) return;
+        if (!this.isTranslatableText(text)) return;
         if (this.isInsideTranslationCall(nodePath)) return;
         const context = this.mapAttrToContext(attrName);
         this.addDetected(
@@ -96,21 +337,23 @@ var AstScanner = class {
           "JSXAttribute"
         );
       },
+      // ── StringLiteral in JS/TS expressions ─────────────────────────────────
       StringLiteral: (nodePath) => {
         if (t.isImportDeclaration(nodePath.parent)) return;
         if (t.isObjectProperty(nodePath.parent) && nodePath.parent.key === nodePath.node) return;
-        if (t.isJSXAttribute(nodePath.parent)) {
-          const attrName = t.isJSXIdentifier(nodePath.parent.name) ? nodePath.parent.name.name.toLowerCase() : "";
-          if (attrName === "classname" || attrName === "class") return;
-          return;
+        if (t.isJSXAttribute(nodePath.parent)) return;
+        if (t.isObjectProperty(nodePath.parent) && t.isIdentifier(nodePath.parent.key)) {
+          if (NON_TRANSLATABLE_PROP_KEYS.has(nodePath.parent.key.name)) return;
         }
+        if (this.isInsideCssUtilityCall(nodePath)) return;
         if (this.isInsideTranslationCall(nodePath)) return;
         const val = nodePath.node.value;
-        if (/^[a-z][a-z0-9_.-]*$/.test(val) || /^#?[0-9a-fA-F]+$/.test(val) || /^[\w-]+\s[\w- ]+$/.test(val) && !val.includes(",")) {
+        if (/^[a-z][a-z0-9_.\-]*$/.test(val) || // all-lowercase token (CSS class / id / key)
+        /^#?[0-9a-fA-F]+$/.test(val)) {
           return;
         }
-        const text = normalizeText(nodePath.node.value);
-        if (!isHumanReadableText(text)) return;
+        const text = normalizeText(val);
+        if (!this.isTranslatableText(text)) return;
         this.addDetected(
           text,
           nodePath.node.loc?.start.line ?? 0,
@@ -119,11 +362,12 @@ var AstScanner = class {
           "StringLiteral"
         );
       },
+      // ── Template literals with no expressions: `Hello world` ───────────────
       TemplateLiteral: (nodePath) => {
         if (nodePath.node.expressions.length > 0) return;
         if (this.isInsideTranslationCall(nodePath)) return;
         const text = normalizeText(nodePath.node.quasis[0]?.value.cooked ?? "");
-        if (!isHumanReadableText(text)) return;
+        if (!this.isTranslatableText(text)) return;
         this.addDetected(
           text,
           nodePath.node.loc?.start.line ?? 0,
@@ -135,6 +379,39 @@ var AstScanner = class {
     });
     return this.detectedTexts;
   }
+  /**
+   * Central check: is this text worth extracting as a locale key?
+   * Applies isHumanReadableText(), isCssClassString(), and user ignoreTextPatterns.
+   */
+  isTranslatableText(text) {
+    if (!isHumanReadableText(text)) return false;
+    if (isCssClassString(text)) return false;
+    if (this.compiledIgnorePatterns.some((re) => re.test(text))) return false;
+    return true;
+  }
+  /**
+   * Returns true when the node path is inside a CSS utility function call:
+   * clsx("a", "b"), cn("x"), twMerge("foo", "bar"), styled("div"), etc.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  isInsideCssUtilityCall(nodePath) {
+    let current = nodePath.parentPath;
+    while (current) {
+      const node = current.node;
+      if (t.isCallExpression(node)) {
+        const callee = node.callee;
+        if (t.isIdentifier(callee) && CSS_UTILITY_FN_NAMES.has(callee.name)) return true;
+        if (t.isMemberExpression(callee) && t.isIdentifier(callee.property) && CSS_UTILITY_FN_NAMES.has(callee.property.name)) return true;
+      }
+      if (t.isTaggedTemplateExpression(node)) {
+        const tag = node.tag;
+        if (t.isIdentifier(tag) && CSS_UTILITY_FN_NAMES.has(tag.name)) return true;
+        if (t.isMemberExpression(tag) && t.isIdentifier(tag.object) && CSS_UTILITY_FN_NAMES.has(tag.object.name)) return true;
+      }
+      current = current.parentPath;
+    }
+    return false;
+  }
   /**
    * Walk import declarations; when the source matches a known translation
    * import, collect all named/default imports as translation function names.
@@ -220,7 +497,7 @@ var AstScanner = class {
       jsxTextRegex.lastIndex = 0;
       while ((m = jsxTextRegex.exec(line)) !== null) {
         const text = normalizeText(m[1]);
-        if (!isHumanReadableText(text)) continue;
+        if (!this.isTranslatableText(text)) continue;
         const key = generateKeyByStyle(
           this.options.filePath,
           text,
@@ -243,22 +520,22 @@ var AstScanner = class {
   }
 };
 function buildImportMatcher(importPackage) {
-  const normalisedPkg = normalisePath(importPackage);
-  const pkgSegments = normalisedPkg.split("/").filter(Boolean);
-  return (source) => {
-    if (source === importPackage) return true;
-    const normSource = normalisePath(source);
-    const srcSegments = normSource.split("/").filter(Boolean);
-    if (pkgSegments.length === 0) return false;
-    const n = pkgSegments.length;
-    if (srcSegments.length < n) return false;
-    const tail = srcSegments.slice(-n);
-    return tail.every((seg, i) => seg.toLowerCase() === pkgSegments[i].toLowerCase());
+  if (!importPackage.startsWith(".") && !importPackage.startsWith("/") && !importPackage.startsWith("@/")) {
+    return (src) => src === importPackage;
+  }
+  const normalise = (s) => s.replace(/^[@./]+/, "").replace(/\\/g, "/").toLowerCase();
+  const normTarget = normalise(importPackage);
+  const targetSegments = normTarget.split("/").filter(Boolean);
+  const segCount = targetSegments.length;
+  return (src) => {
+    if (src === importPackage) return true;
+    const normSrc = normalise(src);
+    const srcSegments = normSrc.split("/").filter(Boolean);
+    if (srcSegments.length < segCount) return false;
+    const tail = srcSegments.slice(-segCount);
+    return tail.join("/") === targetSegments.join("/");
   };
 }
-function normalisePath(p) {
-  return p.replace(/\\/g, "/").replace(/^(@\/|\.{1,2}\/)+/, "").replace(/^@/, "");
-}
 
 // src/asset-scanner.ts
 import * as fs from "fs";
@@ -368,15 +645,27 @@ import { readJsonSafe, writeJson, ensureDir } from "ai-localize-shared";
 var IncrementalScanCache = class {
   cachePath;
   cache;
-  constructor(cacheDir) {
+  /**
+   * @param cacheDir   Directory where `scan-cache.json` is stored.
+   * @param configHash SHA-256 hash of the resolved config object.
+   *                   When this differs from the persisted value the entire
+   *                   cache is invalidated so that config changes (keyStyle,
+   *                   ignoreTextPatterns, codemods, etc.) are always reflected.
+   */
+  constructor(cacheDir, configHash) {
     ensureDir(cacheDir);
     this.cachePath = path2.join(cacheDir, "scan-cache.json");
-    this.cache = this.load();
+    this.cache = this.load(configHash);
   }
-  load() {
+  load(configHash) {
     const existing = readJsonSafe(this.cachePath);
-    if (existing?.version === "1") return existing;
-    return { version: "1", lastRun: (/* @__PURE__ */ new Date()).toISOString(), fileHashes: {}, processedFiles: {} };
+    if (existing?.version === "1") {
+      if (configHash && existing.configHash !== configHash) {
+        return { version: "1", lastRun: (/* @__PURE__ */ new Date()).toISOString(), configHash, fileHashes: {}, processedFiles: {} };
+      }
+      return existing;
+    }
+    return { version: "1", lastRun: (/* @__PURE__ */ new Date()).toISOString(), configHash, fileHashes: {}, processedFiles: {} };
   }
   isFileChanged(filePath) {
     return this.hashFile(filePath) !== this.cache.fileHashes[filePath];
@@ -404,7 +693,13 @@ var IncrementalScanCache = class {
     }
   }
   clear() {
-    this.cache = { version: "1", lastRun: (/* @__PURE__ */ new Date()).toISOString(), fileHashes: {}, processedFiles: {} };
+    this.cache = {
+      version: "1",
+      lastRun: (/* @__PURE__ */ new Date()).toISOString(),
+      configHash: this.cache.configHash,
+      fileHashes: {},
+      processedFiles: {}
+    };
     this.persist();
   }
 };
@@ -412,6 +707,7 @@ var IncrementalScanCache = class {
 // src/project-scanner.ts
 import * as path3 from "path";
 import * as os from "os";
+import * as crypto2 from "crypto";
 import { collectFiles, DEFAULT_IGNORE_DIRS, SOURCE_EXTENSIONS } from "ai-localize-shared";
 var ProjectScanner = class {
   config;
@@ -424,10 +720,39 @@ var ProjectScanner = class {
     this.assetScanner = new AssetScanner(config.aws?.legacyCdnPattern);
     if (config.incrementalCache) {
       this.cache = new IncrementalScanCache(
-        path3.join(process.cwd(), config.cacheDir || ".ai-localize-cache")
+        path3.join(process.cwd(), config.cacheDir || ".ai-localize-cache"),
+        this.hashConfig(config)
       );
     }
   }
+  /**
+   * Produces a stable SHA-256 fingerprint of the config fields that affect
+   * scan output.  When any of these change the incremental cache is fully
+   * invalidated so the next run re-scans every file with the new settings.
+   *
+   * Fields intentionally excluded: `incrementalCache`, `cacheDir`, `aws`,
+   * `plugins` — none of those influence what text the AST scanner detects
+   * or how keys are generated.
+   */
+  hashConfig(config) {
+    const relevant = {
+      framework: config.framework,
+      defaultLanguage: config.defaultLanguage,
+      targetLanguages: config.targetLanguages,
+      sourceDir: config.sourceDir,
+      localesDir: config.localesDir,
+      keyPrefix: config.keyPrefix,
+      namespaces: config.namespaces,
+      ignorePatterns: config.ignorePatterns,
+      includePatterns: config.includePatterns,
+      localeStructure: config.localeStructure,
+      keyStyle: config.keyStyle,
+      staticKeys: config.staticKeys,
+      ignoreTextPatterns: config.ignoreTextPatterns,
+      codemods: config.codemods
+    };
+    return crypto2.createHash("sha256").update(JSON.stringify(relevant)).digest("hex");
+  }
   async scan(options = {}) {
     const startTime = Date.now();
     let filesToScan = [];
@@ -493,7 +818,8 @@ var ProjectScanner = class {
       content,
       sourceRoot: this.sourceRoot,
       codemodConfig: this.config.codemods,
-      keyStyle: this.config.keyStyle ?? "path"
+      keyStyle: this.config.keyStyle ?? "path",
+      ignoreTextPatterns: this.config.ignoreTextPatterns ?? []
     });
     const texts = scanner.scan();
     const { assets, legacyCdnUrls } = this.assetScanner.scanFile(filePath);

package/package.json

@@ -1,10 +1,22 @@
 {
   "name": "ai-localize-scanner",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "AST-based hardcoded text scanner for frontend applications",
+  "author": "ai-localize-core contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ai-localize/ai-localize-core.git",
+    "directory": "packages/scanner"
+  },
+  "homepage": "https://github.com/ai-localize/ai-localize-core/tree/main/packages/scanner#readme",
+  "bugs": {
+    "url": "https://github.com/ai-localize/ai-localize-core/issues"
+  },
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
+  "sideEffects": false,
   "files": [
     "dist",
     "README.md",
@@ -39,8 +51,8 @@
     "@babel/traverse": "^7.23.9",
     "@babel/types": "^7.23.9",
     "glob": "^10.3.10",
-    "ai-localize-shared": "2.0.5",
-    "ai-localize-config": "2.0.5"
+    "ai-localize-shared": "2.0.7",
+    "ai-localize-config": "2.0.7"
   },
   "devDependencies": {
     "@types/babel__traverse": "^7.20.5",
@@ -48,7 +60,6 @@
     "typescript": "^5.3.3",
     "vitest": "^1.2.1"
   },
-  "license": "MIT",
   "publishConfig": {
     "access": "public"
   },