react-i18next-scanner 0.1.5 → 0.1.6

package/dist/core/analysis/collectResolvedImportedObjectTranslationKeys.js

@@ -154,106 +154,157 @@ 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) {
-    const chain = extractPropertyChain(expression);
-    if (!chain) {
-        return null;
+function resolvePropertyChainToTranslationKeys(expression, currentFilePath, importBindings, objectRegistry, availableFiles) {
+    const access = resolveImportedObjectAccess(expression, currentFilePath, importBindings, objectRegistry, availableFiles);
+    if (!access) {
+        return new Set();
     }
-    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(`${access.importedFilePath}::${access.importedName}`);
+    if (!objectMap || access.path.length === 0) {
+        return new Set();
     }
-    const objectMap = objectRegistry.get(`${importedFilePath}::${binding.importedName}`);
-    if (!objectMap) {
-        return null;
-    }
-    const propertyPath = chain.path.join(".");
-    if (!propertyPath) {
-        return null;
-    }
-    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);
+                }
+                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) ?? 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(filePaths);
+    const availableFiles = new Set(normalizedFilePaths);
     const resolvedKeys = new Set();
-    for (const filePath of filePaths) {
+    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);
+        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 = resolvePropertyChainToTranslationKey(firstArg, filePath, importBindings, objectRegistry, availableFiles);
-                    if (directResolved) {
-                        resolvedKeys.add(directResolved);
+                    const directResolved = resolvePropertyChainToTranslationKeys(firstArg, filePath, importBindings, objectRegistry, availableFiles);
+                    for (const key of directResolved) {
+                        resolvedKeys.add(key);
                     }
-                    if (ts.isIdentifier(firstArg)) {
-                        const aliasResolved = localAliases.get(firstArg.text);
-                        if (aliasResolved) {
-                            resolvedKeys.add(aliasResolved);
-                        }
+                    const aliasResolved = resolveAliasPropertyAccessToTranslationKeys(firstArg, objectAliases, keyAliases, objectRegistry);
+                    for (const key of aliasResolved) {
+                        resolvedKeys.add(key);
                     }
                 }
             }
@@ -273,18 +324,57 @@ export async function collectResolvedImportedObjectTranslationKeys(filePaths) {
                 return;
             }
             const expr = i18nKeyAttr.initializer.expression;
-            const directResolved = resolvePropertyChainToTranslationKey(expr, filePath, importBindings, objectRegistry, availableFiles);
-            if (directResolved) {
-                resolvedKeys.add(directResolved);
+            const directResolved = resolvePropertyChainToTranslationKeys(expr, filePath, importBindings, objectRegistry, availableFiles);
+            for (const key of directResolved) {
+                resolvedKeys.add(key);
             }
-            if (ts.isIdentifier(expr)) {
-                const aliasResolved = localAliases.get(expr.text);
-                if (aliasResolved) {
-                    resolvedKeys.add(aliasResolved);
-                }
+            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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-i18next-scanner",
-  "version": "0.1.5",
+  "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": {