react-i18next-scanner 0.1.4 → 0.1.6

package/dist/core/analysis/collectResolvedImportedObjectTranslationKeys.js

@@ -0,0 +1,380 @@
+import fs from "fs/promises";
+import path from "path";
+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 isProbablyTranslationKey(value) {
+    const normalized = value.trim();
+    return (normalized.length > 0 &&
+        !normalized.includes("\n") &&
+        !normalized.includes("\r") &&
+        (normalized.includes(".") || normalized.includes(":")));
+}
+function flattenObjectLiteral(node, prefix = "", result = new Map()) {
+    for (const property of node.properties) {
+        if (!ts.isPropertyAssignment(property)) {
+            continue;
+        }
+        const name = getPropertyName(property.name);
+        if (!name) {
+            continue;
+        }
+        const nextPath = prefix ? `${prefix}.${name}` : name;
+        const initializer = property.initializer;
+        if (ts.isObjectLiteralExpression(initializer)) {
+            flattenObjectLiteral(initializer, nextPath, result);
+            continue;
+        }
+        if (ts.isStringLiteral(initializer) ||
+            ts.isNoSubstitutionTemplateLiteral(initializer)) {
+            const value = initializer.text.trim();
+            if (isProbablyTranslationKey(value)) {
+                result.set(nextPath, value);
+            }
+        }
+    }
+    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);
+}
+function buildObjectRegistry(filePaths, sourceFiles) {
+    const registry = new Map();
+    for (const filePath of filePaths) {
+        const sourceFile = sourceFiles.get(filePath);
+        if (!sourceFile) {
+            continue;
+        }
+        sourceFile.forEachChild((node) => {
+            if (!ts.isVariableStatement(node) || !hasExportModifier(node)) {
+                return;
+            }
+            for (const declaration of node.declarationList.declarations) {
+                if (!ts.isIdentifier(declaration.name) ||
+                    !declaration.initializer ||
+                    !ts.isObjectLiteralExpression(declaration.initializer)) {
+                    continue;
+                }
+                const exportName = declaration.name.text;
+                const values = flattenObjectLiteral(declaration.initializer);
+                if (values.size > 0) {
+                    registry.set(`${filePath}::${exportName}`, values);
+                }
+            }
+        });
+    }
+    return registry;
+}
+function collectImportBindings(sourceFile) {
+    const bindings = new Map();
+    sourceFile.forEachChild((node) => {
+        if (!ts.isImportDeclaration(node)) {
+            return;
+        }
+        if (!node.importClause ||
+            !node.moduleSpecifier ||
+            !ts.isStringLiteral(node.moduleSpecifier)) {
+            return;
+        }
+        const source = node.moduleSpecifier.text;
+        if (node.importClause.namedBindings &&
+            ts.isNamedImports(node.importClause.namedBindings)) {
+            for (const element of node.importClause.namedBindings.elements) {
+                const localName = element.name.text;
+                const importedName = element.propertyName
+                    ? element.propertyName.text
+                    : element.name.text;
+                bindings.set(localName, { importedName, source });
+            }
+        }
+    });
+    return bindings;
+}
+function resolveImportSource(currentFilePath, importSource, availableFiles) {
+    if (!importSource.startsWith(".")) {
+        return null;
+    }
+    const basePath = path.resolve(path.dirname(currentFilePath), importSource);
+    const candidates = [
+        basePath,
+        `${basePath}.ts`,
+        `${basePath}.tsx`,
+        `${basePath}.js`,
+        `${basePath}.jsx`,
+        path.join(basePath, "index.ts"),
+        path.join(basePath, "index.tsx"),
+        path.join(basePath, "index.js"),
+        path.join(basePath, "index.jsx"),
+    ];
+    for (const candidate of candidates) {
+        if (availableFiles.has(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+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 false;
+}
+function isTransTagName(name) {
+    return ts.isIdentifier(name) && name.text === "Trans";
+}
+function getJsxAttribute(attributes, attributeName) {
+    for (const prop of attributes.properties) {
+        if (ts.isJsxAttribute(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === attributeName) {
+            return prop;
+        }
+    }
+    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) {
+    const unwrapped = unwrapExpression(expression);
+    if (ts.isIdentifier(unwrapped)) {
+        return {
+            root: unwrapped.text,
+            path: [],
+        };
+    }
+    if (ts.isPropertyAccessExpression(unwrapped)) {
+        const left = extractPropertyChain(unwrapped.expression);
+        if (!left) {
+            return null;
+        }
+        return {
+            root: left.root,
+            path: [...left.path, unwrapped.name.text],
+        };
+    }
+    if (ts.isElementAccessExpression(unwrapped)) {
+        const left = extractPropertyChain(unwrapped.expression);
+        if (!left) {
+            return null;
+        }
+        const argument = unwrapped.argumentExpression;
+        if (argument &&
+            (ts.isStringLiteral(argument) ||
+                ts.isNoSubstitutionTemplateLiteral(argument))) {
+            return {
+                root: left.root,
+                path: [...left.path, argument.text],
+            };
+        }
+        return {
+            root: left.root,
+            path: [...left.path, "*"],
+        };
+    }
+    return null;
+}
+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 resolveObjectValuesByPath(objectMap, access.path);
+}
+function collectLocalAliases(sourceFile, currentFilePath, importBindings, objectRegistry, availableFiles) {
+    const objectAliases = new Map();
+    const keyAliases = new Map();
+    function visit(node) {
+        if (ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.initializer) {
+            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);
+                }
+                else {
+                    objectAliases.set(node.name.text, importedAccess);
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return { objectAliases, keyAliases };
+}
+function resolveAliasPropertyAccessToTranslationKeys(expression, objectAliases, keyAliases, objectRegistry) {
+    const unwrapped = unwrapExpression(expression);
+    if (ts.isIdentifier(unwrapped)) {
+        return keyAliases.get(unwrapped.text) ?? 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);
+}
+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();
+    for (const filePath of normalizedFilePaths) {
+        const content = await fs.readFile(filePath, "utf-8");
+        sourceFiles.set(filePath, createSourceFile(filePath, content));
+    }
+    const objectRegistry = buildObjectRegistry(normalizedFilePaths, sourceFiles);
+    for (const filePath of normalizedFilePaths) {
+        const sourceFile = sourceFiles.get(filePath);
+        if (!sourceFile) {
+            continue;
+        }
+        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);
+                    }
+                }
+            }
+            if (ts.isJsxSelfClosingElement(node) && isTransTagName(node.tagName)) {
+                collectFromTrans(node.attributes);
+            }
+            if (ts.isJsxOpeningElement(node) && isTransTagName(node.tagName)) {
+                collectFromTrans(node.attributes);
+            }
+            ts.forEachChild(node, visit);
+        }
+        function collectFromTrans(attributes) {
+            const i18nKeyAttr = getJsxAttribute(attributes, "i18nKey");
+            if (!i18nKeyAttr?.initializer ||
+                !ts.isJsxExpression(i18nKeyAttr.initializer) ||
+                !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);
+            }
+            const aliasResolved = resolveAliasPropertyAccessToTranslationKeys(expr, objectAliases, keyAliases, objectRegistry);
+            for (const key of aliasResolved) {
+                resolvedKeys.add(key);
+            }
+        }
+        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,
+    };
+}

package/dist/core/analysis/deepVerifyUnusedKeys.js

@@ -1,5 +1,6 @@
 import fs from "fs/promises";
 import ts from "typescript";
+import { collectResolvedImportedObjectTranslationKeys } from "./collectResolvedImportedObjectTranslationKeys.js";
 const KEY_REGEX = /^[A-Za-z0-9_-]+(?:[.:][A-Za-z0-9_-]+)*$/;
 function getScriptKind(filePath) {
     if (filePath.endsWith(".tsx"))
@@ -220,21 +221,21 @@ function keyMatchesTemplatePrefix(fullKey, localKey, namespace, evidence) {
     }
     return false;
 }
-function keyIsPossiblyDynamic(fullKey, evidenceList) {
+function keyIsPossiblyDynamic(fullKey, evidenceList, resolvedImportedObjectKeys) {
     const { namespace, localKey } = splitKey(fullKey);
+    if (resolvedImportedObjectKeys.has(fullKey)) {
+        return true;
+    }
     for (const evidence of evidenceList) {
-        // case 1: full key exists as a string literal somewhere in code/object
         if (evidence.literalKeys.has(fullKey)) {
             return true;
         }
-        // case 2: local key exists and file uses matching namespace + dynamic t/Trans usage
         if (namespace &&
             evidence.hasDynamicTranslationUsage &&
             evidence.namespaces.has(namespace) &&
             evidence.literalKeys.has(localKey)) {
             return true;
         }
-        // case 3: template literal prefix
         if (keyMatchesTemplatePrefix(fullKey, localKey, namespace, evidence)) {
             return true;
         }
@@ -245,11 +246,12 @@ 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);
     for (const [translationFilePath, unusedKeys] of Object.entries(unusedKeysByFile)) {
         const definitelyUnused = [];
         const possiblyDynamic = [];
         for (const key of unusedKeys) {
-            if (keyIsPossiblyDynamic(key, evidenceList)) {
+            if (keyIsPossiblyDynamic(key, evidenceList, resolvedImportedObjectKeys)) {
                 possiblyDynamic.push(key);
             }
             else {

package/package.json

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