react-i18next-scanner 0.1.0

package/README.md

@@ -0,0 +1,291 @@
+# react-i18next-scanner
+
+CLI tool to scan React projects for missing and unused `react-i18next` translation keys.
+
+## Features
+
+- Scan React source files for translation keys
+- Detect missing translation keys
+- Detect unused translation keys
+- Generate separate unused translation reports
+- Sync missing keys into translation JSON files
+- Remove unused keys from translation JSON files
+- Sort translation JSON files alphabetically
+- Works with `.js`, `.jsx`, `.ts`, `.tsx`
+
+---
+
+## Installation
+
+```bash
+npm install -D react-i18next-scanner
+```
+
+or
+
+```bash
+yarn add -D react-i18next-scanner
+```
+
+---
+
+## Config
+
+Create one of these config files in your project root:
+
+- `i18n-scanner.config.js`
+- `i18n-scanner.config.cjs`
+- `i18n-scanner.config.mjs`
+
+Example:
+
+```js
+export default {
+  srcPaths: ["./src/**/*.{js,jsx,ts,tsx}"],
+  jsonDir: [
+    "./src/i18n/locales/translations.en.json",
+    "./src/i18n/locales/translations.es.json",
+  ],
+  sortJsonFiles: [
+    "./src/i18n/locales/translations.en.json",
+    "./src/i18n/locales/translations.es.json",
+  ],
+  outputDir: "./unused",
+  syncMissing: false,
+  removeUnused: false,
+};
+```
+
+---
+
+## Config Options
+
+### `srcPaths`
+
+Array of source file glob patterns to scan.
+
+```js
+srcPaths: ["./src/**/*.{js,jsx,ts,tsx}"];
+```
+
+### `jsonDir`
+
+Array of translation JSON files to analyze.
+
+```js
+jsonDir: [
+  "./src/i18n/locales/translations.en.json",
+  "./src/i18n/locales/translations.es.json",
+];
+```
+
+### `sortJsonFiles`
+
+Optional array of JSON files for the `sort` command.
+
+```js
+sortJsonFiles: [
+  "./src/i18n/locales/translations.en.json",
+  "./src/i18n/locales/translations.es.json",
+];
+```
+
+### `outputDir`
+
+Directory where unused translation reports will be written.
+
+Default:
+
+```js
+"./unused-translations";
+```
+
+### `syncMissing`
+
+If `true`, missing keys found in code will be added to translation JSON files.
+
+### `removeUnused`
+
+If `true`, unused keys will be removed from translation JSON files.
+
+---
+
+## Commands
+
+### Scan project
+
+```bash
+npx react-i18next-scanner scan
+```
+
+or with custom config:
+
+```bash
+npx react-i18next-scanner scan --config ./i18n-scanner.config.mjs
+```
+
+What it does:
+
+- scans source files
+- extracts translation keys
+- compares them with translation JSON files
+- writes unused translation reports
+- optionally syncs missing keys
+- optionally removes unused keys
+
+---
+
+### Sync missing translations
+
+```bash
+npx react-i18next-scanner sync-missing
+```
+
+This command:
+
+- scans your source files
+- finds missing translation keys
+- adds them to your translation JSON files
+
+---
+
+### Sort translation JSON files
+
+```bash
+npx react-i18next-scanner sort
+```
+
+If no files are passed manually, the command uses `sortJsonFiles` from config.
+
+You can also pass files manually:
+
+```bash
+npx react-i18next-scanner sort ./src/i18n/locales/translations.en.json ./src/i18n/locales/translations.es.json
+```
+
+---
+
+## Unused Translation Reports
+
+When unused keys are found, the scanner creates report files inside `outputDir`.
+
+Example:
+
+- `translations.en.json` → `unused.translations.en.json`
+- `translations.es.json` → `unused.translations.es.json`
+
+These files contain only unused translations, so you can review them safely before deleting anything.
+
+---
+
+## Supported Patterns
+
+The scanner currently detects translation keys used with:
+
+- `t("key")`
+- `i18n.t("key")`
+- `<Trans i18nKey="key" />`
+- `useTranslation("namespace")`
+
+---
+
+## Example Workflow
+
+### 1. Scan without modifying JSON files
+
+```js
+export default {
+  srcPaths: ["./src/**/*.{js,jsx,ts,tsx}"],
+  jsonDir: ["./src/i18n/locales/translations.en.json"],
+  syncMissing: false,
+  removeUnused: false,
+};
+```
+
+Run:
+
+```bash
+npx react-i18next-scanner scan
+```
+
+### 2. Sync missing keys
+
+```js
+export default {
+  srcPaths: ["./src/**/*.{js,jsx,ts,tsx}"],
+  jsonDir: ["./src/i18n/locales/translations.en.json"],
+  syncMissing: true,
+  removeUnused: false,
+};
+```
+
+Run:
+
+```bash
+npx react-i18next-scanner scan
+```
+
+or
+
+```bash
+npx react-i18next-scanner sync-missing
+```
+
+### 3. Remove unused keys
+
+```js
+export default {
+  srcPaths: ["./src/**/*.{js,jsx,ts,tsx}"],
+  jsonDir: ["./src/i18n/locales/translations.en.json"],
+  syncMissing: false,
+  removeUnused: true,
+};
+```
+
+Run:
+
+```bash
+npx react-i18next-scanner scan
+```
+
+---
+
+## Notes
+
+- Use `syncMissing` carefully if you do not want automatic changes in translation files.
+- Use `removeUnused` only after reviewing generated unused translation reports.
+- Translation paths are resolved relative to the config file location.
+
+---
+
+## Development
+
+Build the project:
+
+```bash
+yarn build
+```
+
+Run CLI in development mode:
+
+```bash
+yarn dev scan
+```
+
+Sort JSON files:
+
+```bash
+yarn sort
+```
+
+Sync missing keys:
+
+```bash
+yarn sync
+```
+
+---
+
+## License
+
+ISC

package/dist/cli/cli.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import chalk from "chalk";
+import { runScanner } from "../core/scanner.js";
+import { sortJsonFiles } from "../core/sortJsonFiles.js";
+import { runSyncMissing } from "../core/runSyncMissing.js";
+import { loadConfig } from "../config/loadConfig.js";
+import { findDefaultConfig, POSSIBLE_CONFIGS } from "../config/findConfig.js";
+const program = new Command();
+function resolveConfigPath(configPath) {
+    let finalConfigPath = configPath;
+    if (!finalConfigPath) {
+        finalConfigPath = findDefaultConfig() ?? undefined;
+    }
+    if (!finalConfigPath) {
+        throw new Error(`Config file not found. Create one of: ${POSSIBLE_CONFIGS.join(", ")}`);
+    }
+    return finalConfigPath;
+}
+async function runSyncMissingCommand(opts) {
+    const config = await getConfig(opts);
+    console.log(chalk.cyan("\nSyncing missing translations..."));
+    await runSyncMissing(config);
+    console.log(chalk.green("Missing translations synced successfully!"));
+}
+async function getConfig(opts) {
+    const configPath = resolveConfigPath(opts.config);
+    return await loadConfig(configPath);
+}
+async function runScan(opts) {
+    const config = await getConfig(opts);
+    console.log(chalk.cyan("\nScanning project..."));
+    await runScanner(config);
+    console.log(chalk.green("Scan complete!"));
+}
+async function runSort(files, opts) {
+    let filesToSort = files;
+    if (filesToSort.length === 0) {
+        const config = await getConfig(opts);
+        if (!Array.isArray(config.sortJsonFiles) ||
+            config.sortJsonFiles.length === 0) {
+            throw new Error('No files provided. Pass JSON files manually or add "sortJsonFiles" to your config.');
+        }
+        filesToSort = config.sortJsonFiles;
+    }
+    console.log(chalk.cyan("\nSorting JSON files..."));
+    await sortJsonFiles(filesToSort);
+    console.log(chalk.green("All JSON files sorted successfully!"));
+}
+function handleCliError(error) {
+    if (error instanceof Error) {
+        console.error(chalk.red("Error:"), error.message);
+    }
+    else {
+        console.error(chalk.red("Error:"), String(error));
+    }
+    process.exit(1);
+}
+program
+    .name("react-i18next-scanner")
+    .description("Scan your project for missing and unused i18next translations")
+    .version("1.0.0");
+program
+    .command("scan")
+    .description("Scan project translations")
+    .option("-c, --config <path>", "Path to config file")
+    .action(async (opts) => {
+    try {
+        await runScan(opts);
+    }
+    catch (error) {
+        handleCliError(error);
+    }
+});
+program
+    .command("sync-missing")
+    .description("Scan project and add missing translation keys to JSON files")
+    .option("-c, --config <path>", "Path to config file")
+    .action(async (opts) => {
+    try {
+        await runSyncMissingCommand(opts);
+    }
+    catch (error) {
+        handleCliError(error);
+    }
+});
+program
+    .command("sort [files...]")
+    .description("Sort translation JSON files alphabetically. Uses files from config if none are passed manually.")
+    .option("-c, --config <path>", "Path to config file")
+    .action(async (files, opts) => {
+    try {
+        await runSort(files, opts);
+    }
+    catch (error) {
+        handleCliError(error);
+    }
+});
+await program.parseAsync(process.argv);

package/dist/config/findConfig.js

@@ -0,0 +1,17 @@
+import fs from "fs";
+import path from "path";
+export const POSSIBLE_CONFIGS = [
+    "i18n-scanner.config.js",
+    "i18n-scanner.config.cjs",
+    "i18n-scanner.config.mjs",
+];
+export const findDefaultConfig = () => {
+    const cwd = process.cwd();
+    for (const file of POSSIBLE_CONFIGS) {
+        const fullPath = path.join(cwd, file);
+        if (fs.existsSync(fullPath)) {
+            return fullPath;
+        }
+    }
+    return null;
+};

package/dist/config/loadConfig.js

@@ -0,0 +1,57 @@
+// src/config/loadConfig.ts
+import path from "path";
+import fs from "fs";
+import { pathToFileURL } from "url";
+export async function loadConfig(configPath) {
+    const resolvedPath = path.resolve(process.cwd(), configPath);
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`Config file not found: ${resolvedPath}`);
+    }
+    // if (resolvedPath.endsWith(".ts")) {
+    //   const tsNode = await import("ts-node");
+    //   tsNode.register({ transpileOnly: true });
+    // }
+    const moduleUrl = pathToFileURL(resolvedPath).href;
+    const imported = await import(moduleUrl);
+    const config = imported.default ?? imported;
+    validateConfig(config);
+    return normalizeConfig(config, path.dirname(resolvedPath));
+}
+function validateConfig(config) {
+    if (!config || typeof config !== "object") {
+        throw new Error("Config must export an object.");
+    }
+    const cfg = config;
+    if (!Array.isArray(cfg.jsonDir) ||
+        !cfg.jsonDir.every((x) => typeof x === "string")) {
+        throw new Error("jsonDir must be an array of strings.");
+    }
+    if (!Array.isArray(cfg.srcPaths) ||
+        !cfg.srcPaths.every((x) => typeof x === "string")) {
+        throw new Error("srcPaths must be an array of strings.");
+    }
+    if (cfg.sortJsonFiles !== undefined &&
+        (!Array.isArray(cfg.sortJsonFiles) ||
+            !cfg.sortJsonFiles.every((x) => typeof x === "string"))) {
+        throw new Error("sortJsonFiles must be an array of strings");
+    }
+    if (cfg.removeUnused !== undefined && typeof cfg.removeUnused !== "boolean") {
+        throw new Error("removeUnused must be a boolean.");
+    }
+    if (cfg.syncMissing !== undefined && typeof cfg.syncMissing !== "boolean") {
+        throw new Error("syncMissing must be a boolean.");
+    }
+    if (cfg.outputDir !== undefined && typeof cfg.outputDir !== "string") {
+        throw new Error("outputDir must be a string.");
+    }
+}
+function normalizeConfig(config, baseDir) {
+    return {
+        jsonDir: config.jsonDir.map((d) => path.resolve(baseDir, d)),
+        srcPaths: config.srcPaths.map((p) => path.resolve(baseDir, p)),
+        sortJsonFiles: config.sortJsonFiles?.map((p) => path.resolve(baseDir, p)),
+        removeUnused: config.removeUnused ?? false,
+        syncMissing: config.syncMissing ?? false,
+        outputDir: path.resolve(baseDir, config.outputDir ?? "unused-translations"),
+    };
+}

package/dist/core/actions/removeUnusedTranslations.js

@@ -0,0 +1,28 @@
+import fs from "fs/promises";
+import { removeKey } from "../utils/removeKey.js";
+import { sortObject } from "../utils/sortObject.js";
+export async function removeUnusedTranslations(result, jsonFiles) {
+    const { unusedKeysByFile } = result;
+    for (const file of jsonFiles) {
+        const unusedKeys = unusedKeysByFile[file.filePath] ?? [];
+        if (unusedKeys.length === 0) {
+            continue;
+        }
+        let updated = false;
+        for (const key of unusedKeys) {
+            if (file.keys.has(key)) {
+                removeKey(file.data, key);
+                file.keys.delete(key);
+                updated = true;
+            }
+        }
+        if (!updated) {
+            continue;
+        }
+        const sorted = sortObject(file.data);
+        file.data = sorted;
+        await fs.writeFile(file.filePath, JSON.stringify(sorted, null, 2), "utf-8");
+        console.log(`\n✅ Unused keys removed: ${file.filePath}`);
+        console.log(`➖ Removed: ${unusedKeys.length}`);
+    }
+}

package/dist/core/actions/syncMissingTranslations.js

@@ -0,0 +1,32 @@
+import fs from "fs/promises";
+import { addKey } from "../utils/addKey.js";
+import { sortObject } from "../utils/sortObject.js";
+import { isValidTranslationKey } from "../utils/isValidTranslationKey.js";
+export async function syncMissingTranslations(result, jsonFiles) {
+    const { missingKeysByFile } = result;
+    for (const file of jsonFiles) {
+        const missingKeys = missingKeysByFile[file.filePath] ?? [];
+        if (missingKeys.length === 0) {
+            continue;
+        }
+        let updated = false;
+        for (const key of missingKeys) {
+            if (!isValidTranslationKey(key)) {
+                continue;
+            }
+            if (!file.keys.has(key)) {
+                addKey(file.data, key);
+                file.keys.add(key);
+                updated = true;
+            }
+        }
+        if (!updated) {
+            continue;
+        }
+        const sorted = sortObject(file.data);
+        file.data = sorted;
+        await fs.writeFile(file.filePath, JSON.stringify(sorted, null, 2), "utf-8");
+        console.log(`\n✅ Missing keys synced: ${file.filePath}`);
+        console.log(`➕ Added: ${missingKeys.length}`);
+    }
+}

package/dist/core/actions/writeUnusedTranslationsReport.js

@@ -0,0 +1,47 @@
+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;
+    const filesWithUnused = jsonFiles.filter((file) => {
+        const unusedKeys = unusedKeysByFile[file.filePath] ?? [];
+        return unusedKeys.length > 0;
+    });
+    if (filesWithUnused.length === 0) {
+        return;
+    }
+    await fs.mkdir(outputDir, { recursive: true });
+    for (const file of filesWithUnused) {
+        const unusedKeys = unusedKeysByFile[file.filePath] ?? [];
+        const reportData = {};
+        for (const key of unusedKeys) {
+            const value = getValueByPath(file.data, key);
+            if (value !== undefined) {
+                addKey(reportData, key, value);
+            }
+        }
+        const sorted = sortObject(reportData);
+        const reportFileName = getUnusedReportFileName(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;
+    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/analysis/analyzer.js

@@ -0,0 +1,27 @@
+export function analyzeKeys(usedKeys, jsonFiles) {
+    const missingKeysByFile = {};
+    const unusedKeysByFile = {};
+    for (const file of jsonFiles) {
+        const missingKeys = [];
+        const unusedKeys = [];
+        for (const key of usedKeys) {
+            if (!file.keys.has(key)) {
+                missingKeys.push(key);
+            }
+        }
+        for (const key of file.keys) {
+            if (!usedKeys.has(key)) {
+                unusedKeys.push(key);
+            }
+        }
+        missingKeysByFile[file.filePath] = missingKeys.sort();
+        unusedKeysByFile[file.filePath] = unusedKeys.sort();
+    }
+    const hasMissingKeys = Object.values(missingKeysByFile).some((keys) => keys.length > 0);
+    return {
+        usedKeys: [...usedKeys].sort(),
+        missingKeysByFile,
+        unusedKeysByFile,
+        hasErrors: Object.values(missingKeysByFile).some((keys) => keys.length > 0),
+    };
+}

package/dist/core/analysis/extractKeysFromFiles.js

@@ -0,0 +1,30 @@
+import fs from "fs/promises";
+import { extractKeys } from "../../extractor/keyExtractor.js";
+export async function extractKeysFromFiles(files) {
+    const allKeys = new Set();
+    for (const file of files) {
+        try {
+            const content = await fs.readFile(file, "utf-8");
+            const keys = extractKeys(content);
+            for (const key of keys) {
+                allKeys.add(key);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to read or process file: ${file}. ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return allKeys;
+}
+// const results = await Promise.all(
+//   files.map(async (file) => {
+//     try {
+//       const content = await fs.readFile(file, "utf-8");
+//       const keys = extractKeys(content);
+//       return keys;
+//     } catch (error) {
+//       console.warn(`Failed to read file: ${file}`);
+//       return [];
+//     }
+//   }),
+// );

package/dist/core/io/getFiles.js

@@ -0,0 +1,9 @@
+import fg from "fast-glob";
+export async function getFiles(srcPaths) {
+    const normalizedPatterns = srcPaths.map((pattern) => pattern.replace(/\\/g, "/"));
+    return fg(normalizedPatterns, {
+        ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"],
+        onlyFiles: true,
+        unique: true,
+    });
+}

package/dist/core/io/jsonLoader.js

@@ -0,0 +1,31 @@
+import fs from "fs/promises";
+export async function loadJsonKeys(filePaths) {
+    return Promise.all(filePaths.map(async (file) => {
+        const raw = await fs.readFile(file, "utf8");
+        let data;
+        try {
+            data = JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`Invalid JSON file: ${file}`);
+        }
+        return {
+            filePath: file,
+            data,
+            keys: new Set(flattenKeys(data)),
+        };
+    }));
+}
+function flattenKeys(obj, prefix = "", result = []) {
+    for (const key of Object.keys(obj)) {
+        const value = obj[key];
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            flattenKeys(value, fullKey, result);
+        }
+        else {
+            result.push(fullKey);
+        }
+    }
+    return result;
+}

package/dist/core/runSyncMissing.js

@@ -0,0 +1,14 @@
+import { getFiles } from "./io/getFiles.js";
+import { extractKeysFromFiles } from "./analysis/extractKeysFromFiles.js";
+import { loadJsonKeys } from "./io/jsonLoader.js";
+import { analyzeKeys } from "./analysis/analyzer.js";
+import { syncMissingTranslations } from "./actions/syncMissingTranslations.js";
+export async function runSyncMissing(config) {
+    const files = await getFiles(config.srcPaths);
+    console.log(`🔍 Found ${files.length} files`);
+    const usedKeys = await extractKeysFromFiles(files);
+    const jsonData = await loadJsonKeys(config.jsonDir);
+    const result = analyzeKeys(usedKeys, jsonData);
+    await syncMissingTranslations(result, jsonData);
+    return result;
+}

package/dist/core/scanner.js

@@ -0,0 +1,21 @@
+import { loadJsonKeys } from "./io/jsonLoader.js";
+import { getFiles } from "./io/getFiles.js";
+import { analyzeKeys } from "./analysis/analyzer.js";
+import { extractKeysFromFiles } from "./analysis/extractKeysFromFiles.js";
+import { syncMissingTranslations } from "./actions/syncMissingTranslations.js";
+import { removeUnusedTranslations } from "./actions/removeUnusedTranslations.js";
+import { writeUnusedTranslationsReport } from "./actions/writeUnusedTranslationsReport.js";
+export async function runScanner(config) {
+    const files = await getFiles(config.srcPaths);
+    const usedKeys = await extractKeysFromFiles(files);
+    const jsonData = await loadJsonKeys(config.jsonDir);
+    const result = analyzeKeys(usedKeys, jsonData);
+    await writeUnusedTranslationsReport(result, jsonData, config.outputDir);
+    if (config.syncMissing) {
+        await syncMissingTranslations(result, jsonData);
+    }
+    if (config.removeUnused) {
+        await removeUnusedTranslations(result, jsonData);
+    }
+    return result;
+}

package/dist/core/sortJsonFiles.js

@@ -0,0 +1,30 @@
+import fs from "fs/promises";
+import path from "path";
+import { sortObject } from "./utils/sortObject.js";
+export async function sortJsonFile(filePath) {
+    const resolvedPath = path.resolve(process.cwd(), filePath);
+    if (!resolvedPath.endsWith(".json")) {
+        throw new Error(`Only .json files are supported: ${resolvedPath}`);
+    }
+    let content;
+    try {
+        content = await fs.readFile(resolvedPath, "utf-8");
+    }
+    catch {
+        throw new Error(`JSON file not found: ${resolvedPath}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        throw new Error(`Invalid JSON file: ${resolvedPath}`);
+    }
+    const sorted = sortObject(parsed);
+    await fs.writeFile(resolvedPath, `${JSON.stringify(sorted, null, 2)}\n`, "utf-8");
+}
+export async function sortJsonFiles(filePaths) {
+    for (const filePath of filePaths) {
+        await sortJsonFile(filePath);
+    }
+}

package/dist/core/types.js

@@ -0,0 +1,2 @@
+// src/core/types.ts
+export {};

package/dist/core/utils/addKey.js

@@ -0,0 +1,22 @@
+export function addKey(obj, keyPath, value = "") {
+    const keys = keyPath.split(".");
+    let current = obj;
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (i === keys.length - 1) {
+            if (!(key in current)) {
+                current[key] = value;
+            }
+            return;
+        }
+        if (!(key in current)) {
+            current[key] = {};
+        }
+        else if (typeof current[key] !== "object" ||
+            current[key] === null ||
+            Array.isArray(current[key])) {
+            throw new Error(`Cannot create nested key ${keyPath} because ${keys.slice(0, i + 1).join(".")} is not an object`);
+        }
+        current = current[key];
+    }
+}

package/dist/core/utils/isValidTranslationKey.js

@@ -0,0 +1,7 @@
+export function isValidTranslationKey(key) {
+    const normalized = key.trim();
+    return (normalized.length > 0 &&
+        !normalized.startsWith(".") &&
+        !normalized.endsWith(".") &&
+        !normalized.includes(".."));
+}

package/dist/core/utils/removeKey.js

@@ -0,0 +1,28 @@
+export function removeKey(obj, keyPath) {
+    const parts = keyPath.split(".");
+    const stack = [];
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        const next = current[part];
+        if (typeof next !== "object" || next === null || Array.isArray(next)) {
+            return;
+        }
+        stack.push({ parent: current, key: part });
+        current = next;
+    }
+    delete current[parts[parts.length - 1]];
+    for (let i = stack.length - 1; i >= 0; i--) {
+        const { parent, key } = stack[i];
+        const value = parent[key];
+        if (typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value) &&
+            Object.keys(value).length === 0) {
+            delete parent[key];
+        }
+        else {
+            break;
+        }
+    }
+}

package/dist/core/utils/sortObject.js

@@ -0,0 +1,22 @@
+export function sortObject(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map((item) => sortObject(item));
+    }
+    if (typeof obj !== "object" || obj === null) {
+        return obj;
+    }
+    return Object.keys(obj)
+        .sort((a, b) => {
+        const insensitiveCompare = a.localeCompare(b, undefined, {
+            sensitivity: "base",
+        });
+        if (insensitiveCompare !== 0) {
+            return insensitiveCompare;
+        }
+        return a.localeCompare(b);
+    })
+        .reduce((acc, key) => {
+        acc[key] = sortObject(obj[key]);
+        return acc;
+    }, {});
+}

package/dist/extractor/keyExtractor.js

@@ -0,0 +1,18 @@
+import { shouldScan } from "./shouldScan.js";
+import { extractKeysUltraFast } from "./ultraFast.js";
+import { extractKeysWithRegex } from "./regexExtractor.js";
+// import { extractWithAST } from "./astExtractor";
+export function extractKeys(content) {
+    if (!shouldScan(content)) {
+        return [];
+    }
+    const fastKeys = extractKeysUltraFast(content);
+    const needsDeepScan = content.includes("useTranslation") ||
+        content.includes("<Trans") ||
+        content.includes("i18n.t");
+    if (!needsDeepScan) {
+        return fastKeys;
+    }
+    const regexKeys = extractKeysWithRegex(content);
+    return [...new Set([...fastKeys, ...regexKeys])];
+}

package/dist/extractor/regexExtractor.js

@@ -0,0 +1,43 @@
+export function extractKeysWithRegex(content) {
+    const keys = new Set();
+    const namespaces = new Set();
+    const nsRegex = /useTranslation\s*\(\s*(?:\[\s*([^\]]+)\s*\]|['"`]([^'"`]+)['"`])?/g;
+    let nsMatch;
+    while ((nsMatch = nsRegex.exec(content)) !== null) {
+        if (nsMatch[1]) {
+            const nsValues = nsMatch[1]
+                .split(",")
+                .map((s) => s.replace(/['"`]/g, "").trim())
+                .filter(Boolean);
+            nsValues.forEach((ns) => namespaces.add(ns));
+        }
+        if (nsMatch[2]) {
+            namespaces.add(nsMatch[2]);
+        }
+    }
+    const tRegex = /(^|[^\w$.])t\s*\(\s*['"`]([^'"`]+)['"`]/g;
+    let match;
+    while ((match = tRegex.exec(content)) !== null) {
+        const key = match[2];
+        if (key.includes(".")) {
+            keys.add(key);
+        }
+        else if (namespaces.size > 0) {
+            namespaces.forEach((ns) => keys.add(`${ns}.${key}`));
+        }
+        else {
+            keys.add(key);
+        }
+    }
+    const i18nRegex = /i18n\.t\s*\(\s*['"`]([^'"`]+)['"`]/g;
+    let i18nMatch;
+    while ((i18nMatch = i18nRegex.exec(content)) !== null) {
+        keys.add(i18nMatch[1]);
+    }
+    const transRegex = /<Trans[^>]*i18nKey\s*=\s*['"`]([^'"`]+)['"`]/g;
+    let transMatch;
+    while ((transMatch = transRegex.exec(content)) !== null) {
+        keys.add(transMatch[1]);
+    }
+    return [...keys];
+}

package/dist/extractor/shouldScan.js

@@ -0,0 +1,6 @@
+export function shouldScan(content) {
+    return (/(^|[^\w$.])t\s*\(/.test(content) ||
+        content.includes("i18n.t") ||
+        content.includes("useTranslation") ||
+        content.includes("<Trans"));
+}

package/dist/extractor/ultraFast.js

@@ -0,0 +1,31 @@
+const T_LOOKAHEAD = 80;
+const TRANS_LOOKAHEAD = 150;
+export function extractKeysUltraFast(content) {
+    const keys = new Set();
+    const len = content.length;
+    for (let i = 0; i < len; i++) {
+        const char = content[i];
+        // t(
+        if (char === "t" && (i === 0 || !/[\w$.]/.test(content[i - 1] ?? ""))) {
+            const slice = content.slice(i, i + T_LOOKAHEAD);
+            const match = /^t\s*\(\s*['"`]([^'"`]+)['"`]/.exec(slice);
+            if (match)
+                keys.add(match[1]);
+        }
+        // i18n.t(
+        if (char === "i" && content.slice(i, i + 7) === "i18n.t(") {
+            const slice = content.slice(i, i + T_LOOKAHEAD);
+            const match = /^i18n\.t\s*\(\s*['"`]([^'"`]+)['"`]/.exec(slice);
+            if (match)
+                keys.add(match[1]);
+        }
+        // <Trans ... i18nKey="..." />
+        if (char === "<" && content.slice(i, i + 6) === "<Trans") {
+            const slice = content.slice(i, i + TRANS_LOOKAHEAD);
+            const match = /i18nKey\s*=\s*['"`]([^'"`]+)['"`]/.exec(slice);
+            if (match)
+                keys.add(match[1]);
+        }
+    }
+    return [...keys];
+}

package/dist/reporters/consoleReporter.js

@@ -0,0 +1,8 @@
+import chalk from "chalk";
+export function printConsoleReport(result) {
+    console.log("");
+    console.log(chalk.blue(`Used keys: ${result.usedKeys.length}`));
+    console.log(chalk.yellow(`Unused keys: ${result.unusedKeysByFile.size}`));
+    console.log(chalk.red(`Missing keys: ${result.missingKeysByFile.size}`));
+    console.log("");
+}

package/dist/reporters/writeUnusedKeysReport.js

@@ -0,0 +1,43 @@
+import fs from "fs/promises";
+import path from "path";
+import { addKey } from "../core/utils/addKey.js";
+import { sortObject } from "../core/utils/sortObject.js";
+export async function writeUnusedKeysReport(result, jsonFiles, outputDir) {
+    const { unusedKeysByFile } = result;
+    const filesWithUnused = jsonFiles.filter((file) => {
+        const unusedKeys = unusedKeysByFile[file.filePath] ?? [];
+        return unusedKeys.length > 0;
+    });
+    if (filesWithUnused.length === 0) {
+        return;
+    }
+    await fs.mkdir(outputDir, { recursive: true });
+    for (const file of filesWithUnused) {
+        const unusedKeys = unusedKeysByFile[file.filePath] ?? [];
+        const reportData = {};
+        for (const key of unusedKeys) {
+            const value = getValueByPath(file.data, key);
+            if (value !== undefined) {
+                addKey(reportData, key, value);
+            }
+        }
+        const sorted = sortObject(reportData);
+        const reportFileName = `unused.${path.basename(file.filePath)}`;
+        const reportPath = path.join(outputDir, reportFileName);
+        await fs.writeFile(reportPath, JSON.stringify(sorted, null, 2), "utf8");
+    }
+}
+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/utils/translationUtils.js

@@ -0,0 +1,32 @@
+export function getUsedKeysFromSource(content) {
+    const keys = [];
+    const nsRegex = /useTranslation\s*\(\s*(?:\[\s*([^\]]+)\s*\]|['"`]([^'"`]+)['"`])?/g;
+    const namespaces = [];
+    let nsMatch;
+    while ((nsMatch = nsRegex.exec(content)) !== null) {
+        if (nsMatch[1]) {
+            const nsValues = nsMatch[1]
+                .split(",")
+                .map((s) => s.replace(/['"`]/g, "").trim());
+            namespaces.push(...nsValues);
+        }
+        if (nsMatch[2]) {
+            namespaces.push(nsMatch[2]);
+        }
+    }
+    const tRegex = /\bt\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g;
+    let match;
+    while ((match = tRegex.exec(content)) !== null) {
+        const key = match[1];
+        if (key.includes(".")) {
+            keys.push(key);
+        }
+        else if (namespaces.length > 0) {
+            namespaces.forEach((ns) => keys.push(`${ns}.${key}`));
+        }
+        else {
+            keys.push(key);
+        }
+    }
+    return [...new Set(keys)];
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "react-i18next-scanner",
+  "version": "0.1.0",
+  "description": "CLI tool to scan React projects for missing and unused react-i18next translation keys",
+  "bin": {
+    "react-i18next-scanner": "./dist/cli/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli/cli.ts",
+    "scan": "yarn build && node ./dist/cli/cli.js scan",
+    "sort": "yarn build && node ./dist/cli/cli.js sort",
+    "sync": "yarn build && node ./dist/cli/cli.js sync-missing"
+  },
+  "keywords": [
+    "i18n",
+    "react",
+    "translations",
+    "scanner"
+  ],
+  "author": "Boybekov Abdullokh",
+  "license": "ISC",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^24.6.2",
+    "tsx": "^4.22.4",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^15.0.0",
+    "fast-glob": "^3.3.3"
+  }
+}