react-i18next-scanner 0.1.5 → 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,
+                });
             }
         }
     });
@@ -154,39 +157,93 @@ function getJsxAttribute(attributes, attributeName) {
     }
     return undefined;
 }
+function unwrapExpression(expression) {
+    let current = expression;
+    while (true) {
+        if (ts.isParenthesizedExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        if (ts.isAsExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        if (ts.isTypeAssertionExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        if (ts.isNonNullExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        if (ts.isCallExpression(current) &&
+            ts.isIdentifier(current.expression) &&
+            current.expression.text === "String" &&
+            current.arguments[0]) {
+            current = current.arguments[0];
+            continue;
+        }
+        return current;
+    }
+}
 function extractPropertyChain(expression) {
-    if (ts.isIdentifier(expression)) {
+    const unwrapped = unwrapExpression(expression);
+    if (ts.isIdentifier(unwrapped)) {
         return {
-            root: expression.text,
+            root: unwrapped.text,
             path: [],
         };
     }
-    if (ts.isPropertyAccessExpression(expression)) {
-        const left = extractPropertyChain(expression.expression);
+    if (ts.isPropertyAccessExpression(unwrapped)) {
+        const left = extractPropertyChain(unwrapped.expression);
         if (!left) {
             return null;
         }
         return {
             root: left.root,
-            path: [...left.path, expression.name.text],
+            path: [...left.path, unwrapped.name.text],
         };
     }
-    if (ts.isElementAccessExpression(expression)) {
-        const left = extractPropertyChain(expression.expression);
-        if (!left || !expression.argumentExpression) {
+    if (ts.isElementAccessExpression(unwrapped)) {
+        const left = extractPropertyChain(unwrapped.expression);
+        if (!left) {
             return null;
         }
-        if (ts.isStringLiteral(expression.argumentExpression) ||
-            ts.isNoSubstitutionTemplateLiteral(expression.argumentExpression)) {
+        const argument = unwrapped.argumentExpression;
+        if (argument &&
+            (ts.isStringLiteral(argument) ||
+                ts.isNoSubstitutionTemplateLiteral(argument))) {
             return {
                 root: left.root,
-                path: [...left.path, expression.argumentExpression.text],
+                path: [...left.path, argument.text],
             };
         }
+        return {
+            root: left.root,
+            path: [...left.path, "*"],
+        };
     }
     return null;
 }
-function resolvePropertyChainToTranslationKey(expression, currentFilePath, importBindings, objectRegistry, availableFiles) {
+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;
@@ -203,67 +260,171 @@ function resolvePropertyChainToTranslationKey(expression, currentFilePath, impor
     if (!objectMap) {
         return null;
     }
-    const propertyPath = chain.path.join(".");
-    if (!propertyPath) {
-        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) {
+        return new Set();
+    }
+    const objectMap = objectRegistry.get(`${access.importedFilePath}::${access.importedName}`);
+    if (!objectMap || access.path.length === 0) {
+        return new Set();
     }
-    return objectMap.get(propertyPath) ?? null;
+    return resolveObjectValuesByPath(objectMap, access.path);
 }
 function collectLocalAliases(sourceFile, currentFilePath, importBindings, objectRegistry, availableFiles) {
-    const aliases = new Map();
+    const objectAliases = new Map();
+    const keyAliases = new Map();
     function visit(node) {
         if (ts.isVariableDeclaration(node) &&
             ts.isIdentifier(node.name) &&
             node.initializer) {
-            const resolvedKey = resolvePropertyChainToTranslationKey(node.initializer, currentFilePath, importBindings, objectRegistry, availableFiles);
-            if (resolvedKey) {
-                aliases.set(node.name.text, resolvedKey);
+            const initializer = unwrapExpression(node.initializer);
+            const importedAccess = resolveImportedObjectAccess(initializer, currentFilePath, importBindings, objectRegistry, availableFiles);
+            if (importedAccess) {
+                const keys = resolvePropertyChainToTranslationKeys(initializer, currentFilePath, importBindings, objectRegistry, availableFiles);
+                if (keys.size > 0) {
+                    keyAliases.set(node.name.text, {
+                        keys,
+                        access: importedAccess,
+                    });
+                }
+                else {
+                    objectAliases.set(node.name.text, importedAccess);
+                }
             }
         }
         ts.forEachChild(node, visit);
     }
     visit(sourceFile);
-    return aliases;
+    return {
+        objectAliases,
+        keyAliases,
+    };
+}
+function resolveAliasPropertyAccessToTranslationKeys(expression, objectAliases, keyAliases, objectRegistry) {
+    const unwrapped = unwrapExpression(expression);
+    if (ts.isIdentifier(unwrapped)) {
+        return keyAliases.get(unwrapped.text)?.keys ?? new Set();
+    }
+    const chain = extractPropertyChain(unwrapped);
+    if (!chain) {
+        return new Set();
+    }
+    const objectAlias = objectAliases.get(chain.root);
+    if (!objectAlias) {
+        return new Set();
+    }
+    const objectMap = objectRegistry.get(`${objectAlias.importedFilePath}::${objectAlias.importedName}`);
+    if (!objectMap) {
+        return new Set();
+    }
+    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(filePaths);
+    const availableFiles = new Set(normalizedFilePaths);
     const resolvedKeys = new Set();
-    for (const filePath of filePaths) {
+    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));
     }
-    const objectRegistry = buildObjectRegistry(filePaths, sourceFiles);
-    for (const filePath of filePaths) {
+    const objectRegistry = buildObjectRegistry(normalizedFilePaths, sourceFiles);
+    for (const filePath of normalizedFilePaths) {
         const sourceFile = sourceFiles.get(filePath);
         if (!sourceFile) {
             continue;
         }
         const importBindings = collectImportBindings(sourceFile);
-        const localAliases = collectLocalAliases(sourceFile, filePath, importBindings, objectRegistry, availableFiles);
-        function visit(node) {
-            if (ts.isCallExpression(node) && isTranslationCall(node)) {
-                const firstArg = node.arguments[0];
-                if (firstArg) {
-                    const directResolved = resolvePropertyChainToTranslationKey(firstArg, filePath, importBindings, objectRegistry, availableFiles);
-                    if (directResolved) {
-                        resolvedKeys.add(directResolved);
-                    }
-                    if (ts.isIdentifier(firstArg)) {
-                        const aliasResolved = localAliases.get(firstArg.text);
-                        if (aliasResolved) {
-                            resolvedKeys.add(aliasResolved);
-                        }
-                    }
-                }
+        const { objectAliases, keyAliases } = collectLocalAliases(sourceFile, filePath, importBindings, objectRegistry, availableFiles);
+        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");
@@ -272,19 +433,27 @@ export async function collectResolvedImportedObjectTranslationKeys(filePaths) {
                 !i18nKeyAttr.initializer.expression) {
                 return;
             }
-            const expr = i18nKeyAttr.initializer.expression;
-            const directResolved = resolvePropertyChainToTranslationKey(expr, filePath, importBindings, objectRegistry, availableFiles);
-            if (directResolved) {
-                resolvedKeys.add(directResolved);
-            }
-            if (ts.isIdentifier(expr)) {
-                const aliasResolved = localAliases.get(expr.text);
-                if (aliasResolved) {
-                    resolvedKeys.add(aliasResolved);
+            collectFromExpression(i18nKeyAttr.initializer.expression, "Trans");
+        }
+        function visit(node) {
+            if (ts.isCallExpression(node) && isTranslationCall(node)) {
+                const firstArg = node.arguments[0];
+                if (firstArg) {
+                    collectFromExpression(firstArg, "t");
                 }
             }
+            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;
+    return {
+        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.5",
+  "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": {