react-i18next-scanner 0.1.2 → 0.1.3

package/dist/core/analysis/detectDynamicTranslationUsages.js

@@ -1,94 +1,180 @@
 import fs from "fs/promises";
 import path from "path";
-function extractNamespaces(content) {
-    const namespaces = new Set();
-    const nsRegex = /useTranslation\s*\(\s*(?:\[\s*([^\]]+)\s*\]|['"`]([^'"`]+)['"`])?/g;
-    let match;
-    while ((match = nsRegex.exec(content)) !== null) {
-        if (match[1]) {
-            const values = match[1]
-                .split(",")
-                .map((value) => value.replace(/['"`]/g, "").trim())
-                .filter(Boolean);
-            values.forEach((value) => namespaces.add(value));
+import ts from "typescript";
+function getScriptKind(filePath) {
+    if (filePath.endsWith(".tsx"))
+        return ts.ScriptKind.TSX;
+    if (filePath.endsWith(".ts"))
+        return ts.ScriptKind.TS;
+    if (filePath.endsWith(".jsx"))
+        return ts.ScriptKind.JSX;
+    return ts.ScriptKind.JS;
+}
+function createSourceFile(filePath, content) {
+    return ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, getScriptKind(filePath));
+}
+function extractImportMap(sourceFile) {
+    const imports = new Map();
+    sourceFile.forEachChild((node) => {
+        if (!ts.isImportDeclaration(node))
+            return;
+        if (!node.importClause || !node.moduleSpecifier)
+            return;
+        if (!ts.isStringLiteral(node.moduleSpecifier))
+            return;
+        const modulePath = node.moduleSpecifier.text;
+        const importClause = node.importClause;
+        if (importClause.name) {
+            imports.set(importClause.name.text, modulePath);
         }
-        if (match[2]) {
-            namespaces.add(match[2]);
+        if (importClause.namedBindings &&
+            ts.isNamedImports(importClause.namedBindings)) {
+            for (const element of importClause.namedBindings.elements) {
+                const localName = element.name.text;
+                imports.set(localName, modulePath);
+            }
         }
-    }
-    return [...namespaces];
+    });
+    return imports;
 }
-function extractDynamicTExpressions(content) {
-    const expressions = new Set();
-    const dynamicTRegex = /(^|[^\w$.])t\s*\(\s*([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*(?:\([^()]*\))?)/g;
-    let match;
-    while ((match = dynamicTRegex.exec(content)) !== null) {
-        const expression = match[2]?.trim();
-        if (!expression) {
-            continue;
+function extractNamespaces(sourceFile) {
+    const namespaces = new Set();
+    function visit(node) {
+        if (ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === "useTranslation") {
+            const firstArg = node.arguments[0];
+            if (!firstArg) {
+                return;
+            }
+            if (ts.isStringLiteral(firstArg) ||
+                ts.isNoSubstitutionTemplateLiteral(firstArg)) {
+                namespaces.add(firstArg.text);
+            }
+            if (ts.isArrayLiteralExpression(firstArg)) {
+                for (const element of firstArg.elements) {
+                    if (ts.isStringLiteral(element) ||
+                        ts.isNoSubstitutionTemplateLiteral(element)) {
+                        namespaces.add(element.text);
+                    }
+                }
+            }
         }
-        expressions.add(expression);
+        ts.forEachChild(node, visit);
     }
-    return [...expressions];
+    visit(sourceFile);
+    return [...namespaces];
 }
-function extractImportedIdentifiers(content) {
-    const identifiers = new Set();
-    const importRegex = /import\s+(?:\{([^}]+)\}|([A-Za-z_$][\w$]*))\s+from\s+['"`][^'"`]+['"`]/g;
-    let match;
-    while ((match = importRegex.exec(content)) !== null) {
-        if (match[1]) {
-            const namedImports = match[1]
-                .split(",")
-                .map((value) => value.trim())
-                .map((value) => value.split(" as ")[1]?.trim() ?? value.split(" as ")[0]?.trim())
-                .filter(Boolean);
-            namedImports.forEach((value) => identifiers.add(value));
-        }
-        if (match[2]) {
-            identifiers.add(match[2]);
-        }
+function isTranslationCall(node) {
+    if (ts.isIdentifier(node.expression)) {
+        return node.expression.text === "t";
+    }
+    if (ts.isPropertyAccessExpression(node.expression)) {
+        return node.expression.name.text === "t";
     }
-    return [...identifiers];
+    return false;
 }
-function detectObjectBasedUsageHints(content, importedIdentifiers) {
-    const hints = new Set();
-    for (const identifier of importedIdentifiers) {
-        const objectAccessRegex = new RegExp(`${identifier}\\s*\\[[^\\]]+\\]\\.(description|label|title|placeholder|message)|${identifier}\\.[A-Za-z_$][\\w$]*\\.(description|label|title|placeholder|message)`, "g");
-        if (objectAccessRegex.test(content)) {
-            hints.add(identifier);
+function isDirectLiteralTranslationArg(node) {
+    return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node);
+}
+function getExpressionKind(node) {
+    if (ts.isTemplateExpression(node))
+        return "template-literal";
+    if (ts.isIdentifier(node))
+        return "identifier";
+    if (ts.isCallExpression(node))
+        return "function-call";
+    if (ts.isPropertyAccessExpression(node))
+        return "property-access";
+    if (ts.isElementAccessExpression(node))
+        return "element-access";
+    if (ts.isBinaryExpression(node))
+        return "binary-expression";
+    if (ts.isConditionalExpression(node))
+        return "conditional-expression";
+    return "expression";
+}
+function findRelatedImports(expressionText, importMap) {
+    const related = [];
+    for (const [localName, source] of importMap.entries()) {
+        const identifierRegex = new RegExp(`\\b${localName}\\b`);
+        if (identifierRegex.test(expressionText)) {
+            related.push(`${localName} -> ${source}`);
         }
     }
-    return [...hints];
+    return related;
 }
-function buildFinding(namespaces, expression, objectBasedHints) {
-    const isObjectBased = objectBasedHints.length > 0;
+function buildFinding(namespaces, expression, kind, importHints) {
+    let reason = "Non-literal translation key";
+    let suggestion = "Translation key is not passed as a direct string literal. Manual or deeper analysis may be required.";
+    if (kind === "template-literal") {
+        reason = "Template-literal translation key";
+        suggestion =
+            "Translation key uses a template literal with dynamic interpolation. Manual or deeper analysis may be required.";
+    }
+    if (kind === "function-call") {
+        reason = "Function-based translation key";
+        suggestion =
+            "Translation key is returned from a function call. Manual or deeper analysis may be required.";
+    }
+    if (kind === "property-access" ||
+        kind === "element-access" ||
+        kind === "identifier") {
+        reason = "Object-based non-literal translation key";
+        suggestion =
+            "Translation key may come from an object, variable, or imported map. Manual or deeper analysis may be required.";
+    }
+    if (importHints.length > 0) {
+        suggestion += ` Related imports: ${importHints.join(", ")}.`;
+    }
     return {
         namespaces,
         expression,
-        reason: isObjectBased
-            ? "Object-based non-literal translation key"
-            : "Non-literal translation key",
-        suggestion: isObjectBased
-            ? `Translation key may come from imported object(s): ${objectBasedHints.join(", ")}. Manual or deeper analysis may be required.`
-            : "Translation key may come from a variable or helper function. Manual or deeper analysis may be required.",
+        reason,
+        suggestion,
     };
 }
+function collectDynamicFromExpression(expression, namespaces, importMap, sourceFile, bucket) {
+    if (isDirectLiteralTranslationArg(expression)) {
+        return;
+    }
+    if (ts.isConditionalExpression(expression)) {
+        collectDynamicFromExpression(expression.whenTrue, namespaces, importMap, sourceFile, bucket);
+        collectDynamicFromExpression(expression.whenFalse, namespaces, importMap, sourceFile, bucket);
+        return;
+    }
+    const expressionText = expression.getText(sourceFile).trim();
+    const kind = getExpressionKind(expression);
+    const importHints = findRelatedImports(expressionText, importMap);
+    bucket.push(buildFinding(namespaces, expressionText, kind, importHints));
+}
 export async function detectDynamicTranslationUsages(files) {
     const report = {};
     for (const file of files) {
         const content = await fs.readFile(file, "utf-8");
-        if (!content.includes("useTranslation") || !content.includes("t(")) {
+        if (!content.includes("t(")) {
             continue;
         }
-        const namespaces = extractNamespaces(content);
-        const expressions = extractDynamicTExpressions(content);
-        if (expressions.length === 0) {
-            continue;
+        const sourceFile = createSourceFile(file, content);
+        const namespaces = extractNamespaces(sourceFile);
+        const importMap = extractImportMap(sourceFile);
+        const findings = [];
+        function visit(node) {
+            if (ts.isCallExpression(node) && isTranslationCall(node)) {
+                const firstArg = node.arguments[0];
+                if (firstArg) {
+                    collectDynamicFromExpression(firstArg, namespaces, importMap, sourceFile, findings);
+                }
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(sourceFile);
+        if (findings.length > 0) {
+            const relativePath = path
+                .relative(process.cwd(), file)
+                .replace(/\\/g, "/");
+            report[relativePath] = findings;
         }
-        const importedIdentifiers = extractImportedIdentifiers(content);
-        const objectBasedHints = detectObjectBasedUsageHints(content, importedIdentifiers);
-        const relativePath = path.relative(process.cwd(), file).replace(/\\/g, "/");
-        report[relativePath] = expressions.map((expression) => buildFinding(namespaces, expression, objectBasedHints));
     }
     return report;
 }

package/package.json

@@ -1,10 +1,8 @@
 {
   "name": "react-i18next-scanner",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "CLI tool to scan React projects for missing and unused react-i18next translation keys",
-  "bin": {
-    "react-i18next-scanner": "./dist/cli/cli.js"
-  },
+  "bin": "./dist/cli/cli.js",
   "scripts": {
     "build": "tsc",
     "dev": "tsx src/cli/cli.ts",
@@ -26,12 +24,12 @@
   ],
   "devDependencies": {
     "@types/node": "^24.6.2",
-    "tsx": "^4.22.4",
-    "typescript": "^5.9.3"
+    "tsx": "^4.22.4"
   },
   "dependencies": {
     "chalk": "^5.6.2",
     "commander": "^15.0.0",
-    "fast-glob": "^3.3.3"
+    "fast-glob": "^3.3.3",
+    "typescript": "^6.0.3"
   }
 }