react-i18next-scanner 0.1.6 → 0.1.7

package/dist/core/actions/writeResolvedImportedObjectUsageReport.js

@@ -0,0 +1,12 @@
+// src/core/actions/writeResolvedImportedObjectUsagesReport.ts
+import fs from "fs/promises";
+import path from "path";
+export async function writeResolvedImportedObjectUsagesReport(usages, outputDir) {
+    if (usages.length === 0) {
+        return;
+    }
+    const reportDir = outputDir ?? "reports";
+    await fs.mkdir(reportDir, { recursive: true });
+    const reportPath = path.join(reportDir, "resolved-imported-object-usages.json");
+    await fs.writeFile(reportPath, JSON.stringify(usages, null, 2), "utf-8");
+}

package/dist/core/analysis/collectResolvedImportedObjectTranslationKeys.js

@@ -20,6 +20,15 @@ function isProbablyTranslationKey(value) {
         !normalized.includes("\r") &&
         (normalized.includes(".") || normalized.includes(":")));
 }
+function getPropertyName(name) {
+    if (ts.isIdentifier(name)) {
+        return name.text;
+    }
+    if (ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return null;
+}
 function flattenObjectLiteral(node, prefix = "", result = new Map()) {
     for (const property of node.properties) {
         if (!ts.isPropertyAssignment(property)) {
@@ -45,15 +54,6 @@ function flattenObjectLiteral(node, prefix = "", result = new Map()) {
     }
     return result;
 }
-function getPropertyName(name) {
-    if (ts.isIdentifier(name)) {
-        return name.text;
-    }
-    if (ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
-        return name.text;
-    }
-    return null;
-}
 function hasExportModifier(node) {
     return !!node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
 }
@@ -103,7 +103,10 @@ function collectImportBindings(sourceFile) {
                 const importedName = element.propertyName
                     ? element.propertyName.text
                     : element.name.text;
-                bindings.set(localName, { importedName, source });
+                bindings.set(localName, {
+                    importedName,
+                    source,
+                });
             }
         }
     });
@@ -222,6 +225,47 @@ function extractPropertyChain(expression) {
     }
     return null;
 }
+function matchObjectPath(pattern, actual) {
+    if (pattern.length !== actual.length) {
+        return false;
+    }
+    return pattern.every((part, index) => {
+        return part === "*" || part === actual[index];
+    });
+}
+function resolveObjectValuesByPath(objectMap, pathPattern) {
+    const result = new Set();
+    for (const [objectPath, translationKey] of objectMap.entries()) {
+        const actualPath = objectPath.split(".");
+        if (matchObjectPath(pathPattern, actualPath)) {
+            result.add(translationKey);
+        }
+    }
+    return result;
+}
+function resolveImportedObjectAccess(expression, currentFilePath, importBindings, objectRegistry, availableFiles) {
+    const chain = extractPropertyChain(expression);
+    if (!chain) {
+        return null;
+    }
+    const binding = importBindings.get(chain.root);
+    if (!binding) {
+        return null;
+    }
+    const importedFilePath = resolveImportSource(currentFilePath, binding.source, availableFiles);
+    if (!importedFilePath) {
+        return null;
+    }
+    const objectMap = objectRegistry.get(`${importedFilePath}::${binding.importedName}`);
+    if (!objectMap) {
+        return null;
+    }
+    return {
+        importedFilePath,
+        importedName: binding.importedName,
+        path: chain.path,
+    };
+}
 function resolvePropertyChainToTranslationKeys(expression, currentFilePath, importBindings, objectRegistry, availableFiles) {
     const access = resolveImportedObjectAccess(expression, currentFilePath, importBindings, objectRegistry, availableFiles);
     if (!access) {
@@ -245,7 +289,10 @@ function collectLocalAliases(sourceFile, currentFilePath, importBindings, object
             if (importedAccess) {
                 const keys = resolvePropertyChainToTranslationKeys(initializer, currentFilePath, importBindings, objectRegistry, availableFiles);
                 if (keys.size > 0) {
-                    keyAliases.set(node.name.text, keys);
+                    keyAliases.set(node.name.text, {
+                        keys,
+                        access: importedAccess,
+                    });
                 }
                 else {
                     objectAliases.set(node.name.text, importedAccess);
@@ -255,12 +302,15 @@ function collectLocalAliases(sourceFile, currentFilePath, importBindings, object
         ts.forEachChild(node, visit);
     }
     visit(sourceFile);
-    return { objectAliases, keyAliases };
+    return {
+        objectAliases,
+        keyAliases,
+    };
 }
 function resolveAliasPropertyAccessToTranslationKeys(expression, objectAliases, keyAliases, objectRegistry) {
     const unwrapped = unwrapExpression(expression);
     if (ts.isIdentifier(unwrapped)) {
-        return keyAliases.get(unwrapped.text) ?? new Set();
+        return keyAliases.get(unwrapped.text)?.keys ?? new Set();
     }
     const chain = extractPropertyChain(unwrapped);
     if (!chain) {
@@ -277,11 +327,62 @@ function resolveAliasPropertyAccessToTranslationKeys(expression, objectAliases,
     const fullPath = [...objectAlias.path, ...chain.path];
     return resolveObjectValuesByPath(objectMap, fullPath);
 }
+function resolveAliasObjectAccess(expression, objectAliases, keyAliases) {
+    const unwrapped = unwrapExpression(expression);
+    if (ts.isIdentifier(unwrapped)) {
+        return keyAliases.get(unwrapped.text)?.access ?? null;
+    }
+    const chain = extractPropertyChain(unwrapped);
+    if (!chain) {
+        return null;
+    }
+    const objectAlias = objectAliases.get(chain.root);
+    if (!objectAlias) {
+        return null;
+    }
+    return {
+        importedFilePath: objectAlias.importedFilePath,
+        importedName: objectAlias.importedName,
+        path: [...objectAlias.path, ...chain.path],
+    };
+}
+function formatAccessPath(importedName, pathParts) {
+    if (pathParts.length === 0) {
+        return importedName;
+    }
+    return `${importedName}.${pathParts.join(".")}`;
+}
+function addResolvedUsages(usages, usageIds, keys, params) {
+    for (const key of keys) {
+        const usageId = [
+            key,
+            params.sourceFilePath,
+            params.importedFilePath,
+            params.importedObjectName,
+            params.accessPath,
+            params.usageKind,
+        ].join("::");
+        if (usageIds.has(usageId)) {
+            continue;
+        }
+        usageIds.add(usageId);
+        usages.push({
+            key,
+            sourceFilePath: params.sourceFilePath,
+            importedFilePath: params.importedFilePath,
+            importedObjectName: params.importedObjectName,
+            accessPath: params.accessPath,
+            usageKind: params.usageKind,
+        });
+    }
+}
 export async function collectResolvedImportedObjectTranslationKeys(filePaths) {
     const normalizedFilePaths = filePaths.map((filePath) => path.resolve(filePath));
     const sourceFiles = new Map();
     const availableFiles = new Set(normalizedFilePaths);
     const resolvedKeys = new Set();
+    const usages = [];
+    const usageIds = new Set();
     for (const filePath of normalizedFilePaths) {
         const content = await fs.readFile(filePath, "utf-8");
         sourceFiles.set(filePath, createSourceFile(filePath, content));
@@ -294,27 +395,36 @@ export async function collectResolvedImportedObjectTranslationKeys(filePaths) {
         }
         const importBindings = collectImportBindings(sourceFile);
         const { objectAliases, keyAliases } = collectLocalAliases(sourceFile, filePath, importBindings, objectRegistry, availableFiles);
-        function visit(node) {
-            if (ts.isCallExpression(node) && isTranslationCall(node)) {
-                const firstArg = node.arguments[0];
-                if (firstArg) {
-                    const directResolved = resolvePropertyChainToTranslationKeys(firstArg, filePath, importBindings, objectRegistry, availableFiles);
-                    for (const key of directResolved) {
-                        resolvedKeys.add(key);
-                    }
-                    const aliasResolved = resolveAliasPropertyAccessToTranslationKeys(firstArg, objectAliases, keyAliases, objectRegistry);
-                    for (const key of aliasResolved) {
-                        resolvedKeys.add(key);
-                    }
-                }
+        function addKeys(keys) {
+            for (const key of keys) {
+                resolvedKeys.add(key);
             }
-            if (ts.isJsxSelfClosingElement(node) && isTransTagName(node.tagName)) {
-                collectFromTrans(node.attributes);
+        }
+        function collectFromExpression(expression, usageKind) {
+            const directResolved = resolvePropertyChainToTranslationKeys(expression, filePath, importBindings, objectRegistry, availableFiles);
+            addKeys(directResolved);
+            const directAccess = resolveImportedObjectAccess(expression, filePath, importBindings, objectRegistry, availableFiles);
+            if (directAccess && directResolved.size > 0) {
+                addResolvedUsages(usages, usageIds, directResolved, {
+                    sourceFilePath: filePath,
+                    importedFilePath: directAccess.importedFilePath,
+                    importedObjectName: directAccess.importedName,
+                    accessPath: formatAccessPath(directAccess.importedName, directAccess.path),
+                    usageKind,
+                });
             }
-            if (ts.isJsxOpeningElement(node) && isTransTagName(node.tagName)) {
-                collectFromTrans(node.attributes);
+            const aliasResolved = resolveAliasPropertyAccessToTranslationKeys(expression, objectAliases, keyAliases, objectRegistry);
+            addKeys(aliasResolved);
+            const aliasAccess = resolveAliasObjectAccess(expression, objectAliases, keyAliases);
+            if (aliasAccess && aliasResolved.size > 0) {
+                addResolvedUsages(usages, usageIds, aliasResolved, {
+                    sourceFilePath: filePath,
+                    importedFilePath: aliasAccess.importedFilePath,
+                    importedObjectName: aliasAccess.importedName,
+                    accessPath: formatAccessPath(aliasAccess.importedName, aliasAccess.path),
+                    usageKind,
+                });
             }
-            ts.forEachChild(node, visit);
         }
         function collectFromTrans(attributes) {
             const i18nKeyAttr = getJsxAttribute(attributes, "i18nKey");
@@ -323,58 +433,27 @@ export async function collectResolvedImportedObjectTranslationKeys(filePaths) {
                 !i18nKeyAttr.initializer.expression) {
                 return;
             }
-            const expr = i18nKeyAttr.initializer.expression;
-            const directResolved = resolvePropertyChainToTranslationKeys(expr, filePath, importBindings, objectRegistry, availableFiles);
-            for (const key of directResolved) {
-                resolvedKeys.add(key);
+            collectFromExpression(i18nKeyAttr.initializer.expression, "Trans");
+        }
+        function visit(node) {
+            if (ts.isCallExpression(node) && isTranslationCall(node)) {
+                const firstArg = node.arguments[0];
+                if (firstArg) {
+                    collectFromExpression(firstArg, "t");
+                }
             }
-            const aliasResolved = resolveAliasPropertyAccessToTranslationKeys(expr, objectAliases, keyAliases, objectRegistry);
-            for (const key of aliasResolved) {
-                resolvedKeys.add(key);
+            if (ts.isJsxSelfClosingElement(node) && isTransTagName(node.tagName)) {
+                collectFromTrans(node.attributes);
+            }
+            if (ts.isJsxOpeningElement(node) && isTransTagName(node.tagName)) {
+                collectFromTrans(node.attributes);
             }
+            ts.forEachChild(node, visit);
         }
         visit(sourceFile);
     }
-    return resolvedKeys;
-}
-function matchObjectPath(pattern, actual) {
-    if (pattern.length !== actual.length) {
-        return false;
-    }
-    return pattern.every((part, index) => {
-        return part === "*" || part === actual[index];
-    });
-}
-function resolveObjectValuesByPath(objectMap, pathPattern) {
-    const result = new Set();
-    for (const [objectPath, translationKey] of objectMap.entries()) {
-        const actualPath = objectPath.split(".");
-        if (matchObjectPath(pathPattern, actualPath)) {
-            result.add(translationKey);
-        }
-    }
-    return result;
-}
-function resolveImportedObjectAccess(expression, currentFilePath, importBindings, objectRegistry, availableFiles) {
-    const chain = extractPropertyChain(expression);
-    if (!chain) {
-        return null;
-    }
-    const binding = importBindings.get(chain.root);
-    if (!binding) {
-        return null;
-    }
-    const importedFilePath = resolveImportSource(currentFilePath, binding.source, availableFiles);
-    if (!importedFilePath) {
-        return null;
-    }
-    const objectMap = objectRegistry.get(`${importedFilePath}::${binding.importedName}`);
-    if (!objectMap) {
-        return null;
-    }
     return {
-        importedFilePath,
-        importedName: binding.importedName,
-        path: chain.path,
+        keys: resolvedKeys,
+        usages,
     };
 }

package/dist/core/analysis/deepVerifyUnusedKeys.js

@@ -246,7 +246,9 @@ export async function deepVerifyUnusedKeys(sourceFiles, unusedKeysByFile) {
     const definitelyUnusedByFile = {};
     const possiblyDynamicallyUsedByFile = {};
     const evidenceList = await Promise.all(sourceFiles.map((file) => collectFileEvidence(file)));
-    const resolvedImportedObjectKeys = await collectResolvedImportedObjectTranslationKeys(sourceFiles);
+    const resolvedImportedObjectResult = await collectResolvedImportedObjectTranslationKeys(sourceFiles);
+    const resolvedImportedObjectKeys = resolvedImportedObjectResult.keys;
+    const resolvedImportedObjectUsages = resolvedImportedObjectResult.usages;
     for (const [translationFilePath, unusedKeys] of Object.entries(unusedKeysByFile)) {
         const definitelyUnused = [];
         const possiblyDynamic = [];
@@ -264,5 +266,6 @@ export async function deepVerifyUnusedKeys(sourceFiles, unusedKeysByFile) {
     return {
         definitelyUnusedByFile,
         possiblyDynamicallyUsedByFile,
+        resolvedImportedObjectUsages,
     };
 }

package/dist/core/scanner.js

@@ -7,6 +7,7 @@ import { writeDynamicTranslationReport } from "./actions/writeDynamicTranslation
 import { syncMissingTranslations } from "./actions/syncMissingTranslations.js";
 import { removeUnusedTranslations } from "./actions/removeUnusedTranslations.js";
 import { writeUnusedTranslationsReport } from "./actions/writeUnusedTranslationsReport.js";
+import { writeResolvedImportedObjectUsagesReport } from "./actions/writeResolvedImportedObjectUsageReport.js";
 import { deepVerifyUnusedKeys } from "./analysis/deepVerifyUnusedKeys.js";
 export async function runScanner(config) {
     const files = await getFiles(config.srcPaths);
@@ -16,6 +17,7 @@ export async function runScanner(config) {
     const jsonData = await loadJsonKeys(config.jsonDir);
     const result = analyzeKeys(usedKeys, jsonData);
     const verification = await deepVerifyUnusedKeys(files, result.unusedKeysByFile);
+    await writeResolvedImportedObjectUsagesReport(verification.resolvedImportedObjectUsages ?? [], config.outputDir);
     await writeUnusedTranslationsReport(verification.definitelyUnusedByFile, jsonData, config.outputDir);
     if (config.syncMissing) {
         await syncMissingTranslations(result, jsonData, config.sortJson);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-i18next-scanner",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "CLI tool to scan React projects for missing and unused react-i18next translation keys",
   "bin": "./dist/cli/cli.js",
   "scripts": {