react-i18next-scanner 0.1.3 → 0.1.5

package/dist/core/actions/writePossiblyDynamicallyUsedReport.js

@@ -0,0 +1,47 @@
+// src/core/actions/writePossiblyDynamicallyUsedReport.ts
+import fs from "fs/promises";
+import path from "path";
+import { addKey } from "../utils/addKey.js";
+import { sortObject } from "../utils/sortObject.js";
+const DEFAULT_OUTPUT_DIR = path.resolve(process.cwd(), "reports-dynamic");
+export async function writePossiblyDynamicallyUsedReport(keysByFile, jsonFiles, outputDir = DEFAULT_OUTPUT_DIR) {
+    const reportDataByFile = {};
+    for (const file of jsonFiles) {
+        const possibleKeys = keysByFile[file.filePath] ?? [];
+        if (possibleKeys.length === 0) {
+            continue;
+        }
+        const nestedData = {};
+        for (const key of possibleKeys) {
+            const value = getValueByPath(file.data, key);
+            if (value !== undefined) {
+                addKey(nestedData, key, value);
+            }
+        }
+        const relativeTranslationFilePath = path
+            .relative(process.cwd(), file.filePath)
+            .replace(/\\/g, "/");
+        reportDataByFile[relativeTranslationFilePath] = sortObject(nestedData);
+    }
+    if (Object.keys(reportDataByFile).length === 0) {
+        return;
+    }
+    await fs.mkdir(outputDir, { recursive: true });
+    const reportPath = path.join(outputDir, "possibly-dynamically-used.json");
+    await fs.writeFile(reportPath, `${JSON.stringify(sortObject(reportDataByFile), null, 2)}\n`, "utf-8");
+    console.log(`📝 Possibly dynamically used report created: ${reportPath}`);
+}
+function getValueByPath(obj, keyPath) {
+    const parts = keyPath.split(".");
+    let current = obj;
+    for (const part of parts) {
+        if (typeof current !== "object" ||
+            current === null ||
+            Array.isArray(current) ||
+            !(part in current)) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}

package/dist/core/actions/writeUnusedTranslationsReport.js

@@ -2,18 +2,17 @@ import fs from "fs/promises";
 import path from "path";
 import { addKey } from "../utils/addKey.js";
 import { sortObject } from "../utils/sortObject.js";
-export async function writeUnusedTranslationsReport(result, jsonFiles, outputDir) {
-    const { unusedKeysByFile } = result;
+export async function writeUnusedTranslationsReport(keysByFile, jsonFiles, outputDir) {
     const filesWithUnused = jsonFiles.filter((file) => {
-        const unusedKeys = unusedKeysByFile[file.filePath] ?? [];
-        return unusedKeys.length > 0;
+        const keys = keysByFile[file.filePath] ?? [];
+        return keys.length > 0;
     });
     if (filesWithUnused.length === 0) {
         return;
     }
     await fs.mkdir(outputDir, { recursive: true });
     for (const file of filesWithUnused) {
-        const unusedKeys = unusedKeysByFile[file.filePath] ?? [];
+        const unusedKeys = keysByFile[file.filePath] ?? [];
         const reportData = {};
         for (const key of unusedKeys) {
             const value = getValueByPath(file.data, key);
@@ -22,15 +21,12 @@ export async function writeUnusedTranslationsReport(result, jsonFiles, outputDir
             }
         }
         const sorted = sortObject(reportData);
-        const reportFileName = getUnusedReportFileName(file.filePath);
+        const reportFileName = `unused.${path.basename(file.filePath)}`;
         const reportPath = path.join(outputDir, reportFileName);
         await fs.writeFile(reportPath, JSON.stringify(sorted, null, 2), "utf-8");
         console.log(`📝 Unused report created: ${reportPath}`);
     }
 }
-function getUnusedReportFileName(filePath) {
-    return `unused.${path.basename(filePath)}`;
-}
 function getValueByPath(obj, keyPath) {
     const parts = keyPath.split(".");
     let current = obj;

package/dist/core/analysis/collectResolvedImportedObjectTranslationKeys.js

@@ -0,0 +1,290 @@
+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 extractPropertyChain(expression) {
+    if (ts.isIdentifier(expression)) {
+        return {
+            root: expression.text,
+            path: [],
+        };
+    }
+    if (ts.isPropertyAccessExpression(expression)) {
+        const left = extractPropertyChain(expression.expression);
+        if (!left) {
+            return null;
+        }
+        return {
+            root: left.root,
+            path: [...left.path, expression.name.text],
+        };
+    }
+    if (ts.isElementAccessExpression(expression)) {
+        const left = extractPropertyChain(expression.expression);
+        if (!left || !expression.argumentExpression) {
+            return null;
+        }
+        if (ts.isStringLiteral(expression.argumentExpression) ||
+            ts.isNoSubstitutionTemplateLiteral(expression.argumentExpression)) {
+            return {
+                root: left.root,
+                path: [...left.path, expression.argumentExpression.text],
+            };
+        }
+    }
+    return null;
+}
+function resolvePropertyChainToTranslationKey(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;
+    }
+    const propertyPath = chain.path.join(".");
+    if (!propertyPath) {
+        return null;
+    }
+    return objectMap.get(propertyPath) ?? null;
+}
+function collectLocalAliases(sourceFile, currentFilePath, importBindings, objectRegistry, availableFiles) {
+    const aliases = 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);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return aliases;
+}
+export async function collectResolvedImportedObjectTranslationKeys(filePaths) {
+    const sourceFiles = new Map();
+    const availableFiles = new Set(filePaths);
+    const resolvedKeys = new Set();
+    for (const filePath of filePaths) {
+        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 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);
+                        }
+                    }
+                }
+            }
+            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 = 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);
+                }
+            }
+        }
+        visit(sourceFile);
+    }
+    return resolvedKeys;
+}

package/dist/core/analysis/deepVerifyUnusedKeys.js

@@ -0,0 +1,268 @@
+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"))
+        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 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 isDirectLiteral(node) {
+    return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node);
+}
+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 getJsxLiteralAttributeValue(attribute) {
+    if (!attribute?.initializer) {
+        return undefined;
+    }
+    if (ts.isStringLiteral(attribute.initializer)) {
+        return attribute.initializer.text;
+    }
+    if (ts.isJsxExpression(attribute.initializer) &&
+        attribute.initializer.expression &&
+        (ts.isStringLiteral(attribute.initializer.expression) ||
+            ts.isNoSubstitutionTemplateLiteral(attribute.initializer.expression))) {
+        return attribute.initializer.expression.text;
+    }
+    return undefined;
+}
+function splitKey(fullKey) {
+    const firstDotIndex = fullKey.indexOf(".");
+    if (firstDotIndex === -1) {
+        return { localKey: fullKey };
+    }
+    return {
+        namespace: fullKey.slice(0, firstDotIndex),
+        localKey: fullKey.slice(firstDotIndex + 1),
+    };
+}
+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) {
+                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);
+                        }
+                    }
+                }
+            }
+        }
+        if (ts.isJsxSelfClosingElement(node) && isTransTagName(node.tagName)) {
+            const nsValue = getJsxLiteralAttributeValue(getJsxAttribute(node.attributes, "ns"));
+            if (nsValue) {
+                namespaces.add(nsValue);
+            }
+        }
+        if (ts.isJsxOpeningElement(node) && isTransTagName(node.tagName)) {
+            const nsValue = getJsxLiteralAttributeValue(getJsxAttribute(node.attributes, "ns"));
+            if (nsValue) {
+                namespaces.add(nsValue);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return namespaces;
+}
+function collectLiteralKeys(sourceFile) {
+    const keys = new Set();
+    function visit(node) {
+        if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+            const value = node.text.trim();
+            if (KEY_REGEX.test(value)) {
+                keys.add(value);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return keys;
+}
+function collectTemplatePrefixes(sourceFile) {
+    const prefixes = new Set();
+    function addPrefix(prefix) {
+        const normalized = prefix.trim();
+        if (!normalized) {
+            return;
+        }
+        prefixes.add(normalized);
+    }
+    function visit(node) {
+        if (ts.isCallExpression(node) && isTranslationCall(node)) {
+            const firstArg = node.arguments[0];
+            if (firstArg && ts.isTemplateExpression(firstArg)) {
+                addPrefix(firstArg.head.text);
+            }
+        }
+        if (ts.isJsxSelfClosingElement(node) && isTransTagName(node.tagName)) {
+            const i18nKeyAttr = getJsxAttribute(node.attributes, "i18nKey");
+            if (i18nKeyAttr?.initializer &&
+                ts.isJsxExpression(i18nKeyAttr.initializer) &&
+                i18nKeyAttr.initializer.expression &&
+                ts.isTemplateExpression(i18nKeyAttr.initializer.expression)) {
+                addPrefix(i18nKeyAttr.initializer.expression.head.text);
+            }
+        }
+        if (ts.isJsxOpeningElement(node) && isTransTagName(node.tagName)) {
+            const i18nKeyAttr = getJsxAttribute(node.attributes, "i18nKey");
+            if (i18nKeyAttr?.initializer &&
+                ts.isJsxExpression(i18nKeyAttr.initializer) &&
+                i18nKeyAttr.initializer.expression &&
+                ts.isTemplateExpression(i18nKeyAttr.initializer.expression)) {
+                addPrefix(i18nKeyAttr.initializer.expression.head.text);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return [...prefixes];
+}
+function detectDynamicTranslationUsage(sourceFile) {
+    let found = false;
+    function visit(node) {
+        if (found) {
+            return;
+        }
+        if (ts.isCallExpression(node) && isTranslationCall(node)) {
+            const firstArg = node.arguments[0];
+            if (firstArg && !isDirectLiteral(firstArg)) {
+                found = true;
+                return;
+            }
+        }
+        if (ts.isJsxSelfClosingElement(node) && isTransTagName(node.tagName)) {
+            const i18nKeyAttr = getJsxAttribute(node.attributes, "i18nKey");
+            if (i18nKeyAttr?.initializer &&
+                ts.isJsxExpression(i18nKeyAttr.initializer) &&
+                i18nKeyAttr.initializer.expression) {
+                const expr = i18nKeyAttr.initializer.expression;
+                if (!isDirectLiteral(expr)) {
+                    found = true;
+                    return;
+                }
+            }
+        }
+        if (ts.isJsxOpeningElement(node) && isTransTagName(node.tagName)) {
+            const i18nKeyAttr = getJsxAttribute(node.attributes, "i18nKey");
+            if (i18nKeyAttr?.initializer &&
+                ts.isJsxExpression(i18nKeyAttr.initializer) &&
+                i18nKeyAttr.initializer.expression) {
+                const expr = i18nKeyAttr.initializer.expression;
+                if (!isDirectLiteral(expr)) {
+                    found = true;
+                    return;
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return found;
+}
+async function collectFileEvidence(filePath) {
+    const content = await fs.readFile(filePath, "utf-8");
+    const sourceFile = createSourceFile(filePath, content);
+    return {
+        namespaces: extractNamespaces(sourceFile),
+        hasDynamicTranslationUsage: detectDynamicTranslationUsage(sourceFile),
+        literalKeys: collectLiteralKeys(sourceFile),
+        templatePrefixes: collectTemplatePrefixes(sourceFile),
+    };
+}
+function keyMatchesTemplatePrefix(fullKey, localKey, namespace, evidence) {
+    for (const prefix of evidence.templatePrefixes) {
+        if (fullKey.startsWith(prefix)) {
+            return true;
+        }
+        if (namespace &&
+            evidence.namespaces.has(namespace) &&
+            localKey.startsWith(prefix)) {
+            return true;
+        }
+    }
+    return false;
+}
+function keyIsPossiblyDynamic(fullKey, evidenceList, resolvedImportedObjectKeys) {
+    const { namespace, localKey } = splitKey(fullKey);
+    if (resolvedImportedObjectKeys.has(fullKey)) {
+        return true;
+    }
+    for (const evidence of evidenceList) {
+        if (evidence.literalKeys.has(fullKey)) {
+            return true;
+        }
+        if (namespace &&
+            evidence.hasDynamicTranslationUsage &&
+            evidence.namespaces.has(namespace) &&
+            evidence.literalKeys.has(localKey)) {
+            return true;
+        }
+        if (keyMatchesTemplatePrefix(fullKey, localKey, namespace, evidence)) {
+            return true;
+        }
+    }
+    return false;
+}
+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, resolvedImportedObjectKeys)) {
+                possiblyDynamic.push(key);
+            }
+            else {
+                definitelyUnused.push(key);
+            }
+        }
+        definitelyUnusedByFile[translationFilePath] = definitelyUnused;
+        possiblyDynamicallyUsedByFile[translationFilePath] = possiblyDynamic;
+    }
+    return {
+        definitelyUnusedByFile,
+        possiblyDynamicallyUsedByFile,
+    };
+}

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 { deepVerifyUnusedKeys } from "./analysis/deepVerifyUnusedKeys.js";
 export async function runScanner(config) {
     const files = await getFiles(config.srcPaths);
     const dynamicUsages = await detectDynamicTranslationUsages(files);
@@ -14,12 +15,17 @@ export async function runScanner(config) {
     const usedKeys = await extractKeysFromFiles(files);
     const jsonData = await loadJsonKeys(config.jsonDir);
     const result = analyzeKeys(usedKeys, jsonData);
-    await writeUnusedTranslationsReport(result, jsonData, config.outputDir);
+    const verification = await deepVerifyUnusedKeys(files, result.unusedKeysByFile);
+    await writeUnusedTranslationsReport(verification.definitelyUnusedByFile, jsonData, config.outputDir);
     if (config.syncMissing) {
         await syncMissingTranslations(result, jsonData, config.sortJson);
     }
     if (config.removeUnused) {
-        await removeUnusedTranslations(result, jsonData, config.sortJson);
+        const filteredResult = {
+            ...result,
+            unusedKeysByFile: verification.definitelyUnusedByFile,
+        };
+        await removeUnusedTranslations(filteredResult, jsonData, config.sortJson);
     }
     return result;
 }

package/package.json

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