scripts/cleanup-i18n-unused.js
Rama main · réplica de lectura del repositorio original.
#!/usr/bin/env node
// Version: 0.1.15
const { readdir, readFile, writeFile } = require('node:fs/promises');
const { existsSync } = require('node:fs');
const path = require('node:path');
const { detectSrcRoot } = require('./lib/projectConfig');
const { listLocales, deleteKeyPathInObject } = require('./lib/localeUtils');
const projectRoot = path.resolve(__dirname, '..');
const autoDir = path.resolve(projectRoot, 'resources', 'js', 'i18n', 'auto');
const baseLocale = 'en';
const srcRoot = detectSrcRoot(projectRoot);
const srcRoots = (() => {
const roots = new Set();
if (srcRoot && existsSync(srcRoot)) roots.add(srcRoot);
const resourcesJs = path.resolve(projectRoot, 'resources', 'js');
if (existsSync(resourcesJs)) roots.add(resourcesJs);
const srcDir = path.resolve(projectRoot, 'src');
if (existsSync(srcDir)) roots.add(srcDir);
// Fallback: include project root so we don't miss unconventional layouts
roots.add(projectRoot);
return Array.from(roots);
})();
let hadLocaleReadErrors = false;
async function readJsonSafe(filePath) {
try {
const raw = await readFile(filePath, 'utf8');
return JSON.parse(raw);
} catch (err) {
console.error(`[cleanup-i18n-unused] Failed to read/parse JSON: ${filePath}`);
console.error(err?.message || err);
return null;
}
}
async function collectJsonFiles(dir, out) {
const entries = await readdir(dir, { withFileTypes: true });
for (const entry of entries) {
const entryPath = path.join(dir, entry.name);
if (entry.isDirectory()) {
await collectJsonFiles(entryPath, out);
} else if (entry.isFile() && entry.name.endsWith('.json')) {
out.push(entryPath);
}
}
}
function collectKeysFromObject(obj, prefix, localeFileRel, outMap) {
if (!obj || typeof obj !== 'object' || Array.isArray(obj)) return;
for (const [key, value] of Object.entries(obj)) {
const nextPath = prefix ? `${prefix}.${key}` : key;
if (typeof value === 'string') {
if (!outMap.has(nextPath)) {
outMap.set(nextPath, { value, localeFileRel });
}
} else if (value && typeof value === 'object' && !Array.isArray(value)) {
collectKeysFromObject(value, nextPath, localeFileRel, outMap);
}
}
}
async function loadBaseLocaleKeys() {
const keys = new Map();
if (!existsSync(autoDir)) {
return keys;
}
const groupedDir = path.resolve(autoDir, baseLocale);
if (existsSync(groupedDir)) {
const files = [];
await collectJsonFiles(groupedDir, files);
for (const file of files) {
const json = await readJsonSafe(file);
if (!json || typeof json !== 'object') {
hadLocaleReadErrors = true;
continue;
}
const rel = path.relative(autoDir, file).replace(/\\/g, '/');
collectKeysFromObject(json, '', rel, keys);
}
} else {
const singlePath = path.resolve(autoDir, `${baseLocale}.json`);
if (!existsSync(singlePath)) {
return keys;
}
const json = await readJsonSafe(singlePath);
if (!json || typeof json !== 'object') {
hadLocaleReadErrors = true;
return keys;
}
const rel = path.relative(autoDir, singlePath).replace(/\\/g, '/');
collectKeysFromObject(json, '', rel, keys);
}
return keys;
}
async function loadLocaleKeys(locale) {
const keys = new Map();
if (!existsSync(autoDir)) {
return keys;
}
const groupedDir = path.resolve(autoDir, locale);
if (existsSync(groupedDir)) {
const files = [];
await collectJsonFiles(groupedDir, files);
for (const file of files) {
const json = await readJsonSafe(file);
if (!json || typeof json !== 'object') {
continue;
}
const rel = path.relative(autoDir, file).replace(/\\/g, '/');
collectKeysFromObject(json, '', rel, keys);
}
} else {
const singlePath = path.resolve(autoDir, `${locale}.json`);
if (!existsSync(singlePath)) {
return keys;
}
const json = await readJsonSafe(singlePath);
if (!json || typeof json !== 'object') {
return keys;
}
const rel = path.relative(autoDir, singlePath).replace(/\\/g, '/');
collectKeysFromObject(json, '', rel, keys);
}
return keys;
}
async function collectSourceFiles(dir, out) {
const entries = await readdir(dir, { withFileTypes: true });
for (const entry of entries) {
const entryPath = path.join(dir, entry.name);
if (entry.isDirectory()) {
if ([
'node_modules', 'vendor', '.git', 'storage', 'bootstrap', 'public',
'dist', 'build', 'out', 'coverage', '.next', '.nuxt', '.vite', '.turbo',
].includes(entry.name) || entry.name.startsWith('.')) {
continue;
}
await collectSourceFiles(entryPath, out);
} else if (entry.isFile()) {
if (/\.(tsx|ts|jsx|js|vue|svelte|mjs|cjs|mts|cts)$/i.test(entry.name)) {
out.push(entryPath);
}
}
}
}
let cachedUsageIndex = null;
let cachedUsageKeySet = null;
async function buildUsageIndex(candidateKeys) {
const index = Object.create(null);
if (!srcRoots.length) return index;
const keySet = candidateKeys instanceof Set ? candidateKeys : null;
const files = [];
for (const root of srcRoots) {
// eslint-disable-next-line no-await-in-loop
await collectSourceFiles(root, files);
}
const uniqueFiles = Array.from(new Set(files));
console.log(`[cleanup-i18n-unused] Scanning ${uniqueFiles.length} source files for key usage...`);
function getLineNumberFromIndex(text, idx) {
let line = 1;
for (let i = 0; i < idx && i < text.length; i += 1) {
if (text.charCodeAt(i) === 10) line += 1;
}
return line;
}
for (const file of uniqueFiles) {
const rel = path.relative(projectRoot, file).replace(/\\/g, '/');
const code = await readFile(file, 'utf8');
const tCallRegex = /(?:^|[^a-zA-Z0-9_$])\$?t\s*(?:<[^>]+>\s*)?\(\s*(['"`])([A-Za-z0-9_.\-:]+)\1\s*(?:,|\))/g;
let match;
while ((match = tCallRegex.exec(code)) !== null) {
const key = match[2];
if (keySet && !keySet.has(key)) {
continue;
}
if (!index[key]) {
index[key] = [];
}
const line = getLineNumberFromIndex(code, match.index);
index[key].push({ file: rel, line });
}
if (keySet) {
const keyLiteralRegex = /(['"`])([A-Za-z0-9_.\-:]+)\1/g;
while ((match = keyLiteralRegex.exec(code)) !== null) {
const key = match[2];
if (!keySet.has(key)) {
continue;
}
if (!index[key]) {
index[key] = [];
}
const line = getLineNumberFromIndex(code, match.index);
index[key].push({ file: rel, line });
}
}
}
console.log('[cleanup-i18n-unused] Finished building source usage index.');
return index;
}
async function indexKeyUsage(fullKey) {
if (!fullKey) return [];
if (!cachedUsageIndex) {
cachedUsageIndex = await buildUsageIndex(cachedUsageKeySet);
}
return cachedUsageIndex[fullKey] || [];
}
async function applyDeletions(unusedKeys) {
const locales = await listLocales(autoDir);
if (!locales.length) return { filesChanged: 0 };
// Map of absolute file path -> { json, changed }
const fileCache = new Map();
for (const entry of unusedKeys) {
const { keyPath, baseFileRel } = entry;
// Safety guard: skip deletion if key is still referenced in source
const usage = await indexKeyUsage(keyPath);
if (usage && usage.length > 0) {
console.log(`[cleanup-i18n-unused] Skipping "${keyPath}" because it is still referenced in source (${usage.length} usage(s)).`);
continue;
}
for (const locale of locales) {
// Map base file path to target locale file
// If baseFileRel is "en/common.json", map to "fr/common.json"
// If baseFileRel is already locale-specific, use as-is
let rel;
if (baseFileRel.startsWith(`${baseLocale}/`) || baseFileRel.startsWith(`${baseLocale}\\`)) {
// Replace base locale with target locale
rel = baseFileRel.replace(new RegExp(`^${baseLocale}[\\\\/]`), `${locale}/`);
} else {
// File is not locale-specific, use as-is
rel = baseFileRel;
}
const abs = path.resolve(autoDir, rel);
if (!existsSync(abs)) continue;
let cached = fileCache.get(abs);
if (!cached) {
const json = await readJsonSafe(abs);
if (!json || typeof json !== 'object') continue;
cached = { json, changed: false };
fileCache.set(abs, cached);
}
if (deleteKeyPathInObject(cached.json, keyPath)) {
cached.changed = true;
}
}
}
let filesChanged = 0;
for (const [filePath, { json, changed }] of fileCache.entries()) {
if (!changed) continue;
await writeFile(filePath, JSON.stringify(json, null, 2) + '\n', 'utf8');
filesChanged += 1;
console.log(`[cleanup-i18n-unused] Removed unused keys from ${path.relative(projectRoot, filePath)}`);
}
return { filesChanged };
}
async function applyOrphanedDeletions(orphanedKeys) {
// Map of absolute file path -> { json, changed }
const fileCache = new Map();
for (const entry of orphanedKeys) {
const { keyPath, baseFileRel, locale } = entry;
// Only delete from the specific locale where the orphaned key exists
// baseFileRel is already the correct path for this locale
const abs = path.resolve(autoDir, baseFileRel);
if (!existsSync(abs)) continue;
let cached = fileCache.get(abs);
if (!cached) {
const json = await readJsonSafe(abs);
if (!json || typeof json !== 'object') continue;
cached = { json, changed: false };
fileCache.set(abs, cached);
}
if (deleteKeyPathInObject(cached.json, keyPath)) {
cached.changed = true;
console.log(`[cleanup-i18n-unused] Removing orphaned key "${keyPath}" from ${locale} locale`);
}
}
let filesChanged = 0;
for (const [filePath, { json, changed }] of fileCache.entries()) {
if (!changed) continue;
await writeFile(filePath, JSON.stringify(json, null, 2) + '\n', 'utf8');
filesChanged += 1;
console.log(`[cleanup-i18n-unused] Removed orphaned keys from ${path.relative(projectRoot, filePath)}`);
}
return filesChanged;
}
async function main() {
if (!existsSync(autoDir)) {
console.error('[cleanup-i18n-unused] i18n auto directory not found:', autoDir);
process.exit(1);
}
hadLocaleReadErrors = false;
const apply = process.argv.includes('--apply');
const cleanOrphaned = process.argv.includes('--clean-orphaned');
const baseKeys = await loadBaseLocaleKeys();
if (hadLocaleReadErrors) {
console.error('[cleanup-i18n-unused] Aborting: one or more locale JSON files could not be parsed. No locale files were modified.');
process.exit(1);
}
if (baseKeys.size === 0) {
console.log('[cleanup-i18n-unused] No base locale keys found. Nothing to do.');
return;
}
cachedUsageKeySet = new Set(baseKeys.keys());
cachedUsageIndex = await buildUsageIndex(cachedUsageKeySet);
const unused = [];
for (const [keyPath, info] of baseKeys.entries()) {
const usage = await indexKeyUsage(keyPath);
if (!usage || usage.length === 0) {
unused.push({ keyPath, baseFileRel: info.localeFileRel });
}
}
// Find orphaned keys (keys in non-default locales but missing from default locale)
let orphaned = [];
if (cleanOrphaned) {
const locales = await listLocales(autoDir);
for (const locale of locales) {
if (locale === baseLocale) continue; // Skip default locale
const localeKeys = await loadLocaleKeys(locale);
for (const keyPath of localeKeys.keys()) {
// Check if key exists in default locale
if (!baseKeys.has(keyPath)) {
// Key exists in this locale but not in default locale - it's orphaned
const info = localeKeys.get(keyPath);
orphaned.push({ keyPath, baseFileRel: info.localeFileRel, locale });
}
}
}
}
if (unused.length === 0 && orphaned.length === 0) {
console.log('[cleanup-i18n-unused] No unused or orphaned keys detected.');
return;
}
const reportPath = path.resolve(projectRoot, 'scripts', '.i18n-unused-report.json');
const payload = {
generatedAt: new Date().toISOString(),
baseLocale,
autoDir: path.relative(projectRoot, autoDir).replace(/\\/g, '/'),
unused,
orphaned: cleanOrphaned ? orphaned : undefined,
};
await writeFile(reportPath, JSON.stringify(payload, null, 2) + '\n', 'utf8');
console.log(`[cleanup-i18n-unused] Found ${unused.length} unused key(s).`);
if (cleanOrphaned) {
console.log(`[cleanup-i18n-unused] Found ${orphaned.length} orphaned key(s) (missing from default locale).`);
}
console.log(`[cleanup-i18n-unused] Report written to`, path.relative(projectRoot, reportPath));
if (!apply) {
console.log('[cleanup-i18n-unused] Dry run only. Re-run with --apply to delete unused/orphaned keys from locale files.');
if (cleanOrphaned) {
console.log('[cleanup-i18n-unused] Use --clean-orphaned to also remove keys that exist in non-default locales but are missing from the default locale.');
}
return;
}
const { filesChanged } = await applyDeletions(unused);
let orphanedFilesChanged = 0;
if (cleanOrphaned && orphaned.length > 0) {
orphanedFilesChanged = await applyOrphanedDeletions(orphaned);
}
console.log(`[cleanup-i18n-unused] Deleted unused keys from ${filesChanged} locale file(s).`);
if (cleanOrphaned) {
console.log(`[cleanup-i18n-unused] Deleted orphaned keys from ${orphanedFilesChanged} locale file(s).`);
}
}
main().catch((err) => {
console.error('[cleanup-i18n-unused] Failed:', err && err.message ? err.message : err);
process.exit(1);
});