Script to find missing & unused translations added

Signed-off-by: Sanjay Babu <sanjaytkbabu@gmail.com>

Author: sanjaytkbabu

frontend/package.json

@@ -8,6 +8,7 @@
   "scripts": {
     "build": "vite build",
     "build:dts": "vue-tsc --declaration --emitDeclarationOnly",
+    "check:translations": "npx tsx scripts/check-translations.ts",
     "clean": "rimraf coverage dist",
     "debug": "vite --mode debug",
     "format": "prettier ./src --write",

frontend/scripts/check-translations.ts

@@ -0,0 +1,211 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+// Get directory paths
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, '..');
+const srcDir = path.join(projectRoot, 'src');
+const localeFile = path.join(projectRoot, 'src', 'locales', 'en-CA.json');
+
+interface MissingTranslation {
+  file: string;
+  line: number;
+  key: string;
+  context: string;
+}
+
+// Read locale file
+function loadLocaleKeys(): Set<string> {
+  const localeContent = fs.readFileSync(localeFile, 'utf-8');
+  const localeData = JSON.parse(localeContent);
+
+  const keys = new Set<string>();
+
+  function extractKeys(obj: any, prefix = '') {
+    for (const key in obj) {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      if (typeof obj[key] === 'object' && obj[key] !== null) {
+        extractKeys(obj[key], fullKey);
+      } else {
+        keys.add(fullKey);
+      }
+    }
+  }
+
+  extractKeys(localeData);
+  return keys;
+}
+
+// Find all .vue and .ts files recursively
+function findFiles(dir: string, extensions: string[]): string[] {
+  const files: string[] = [];
+
+  function traverse(currentDir: string) {
+    const items = fs.readdirSync(currentDir);
+
+    for (const item of items) {
+      const fullPath = path.join(currentDir, item);
+      const stat = fs.statSync(fullPath);
+
+      if (stat.isDirectory()) {
+        // Skip node_modules, dist, coverage, etc.
+        if (!['node_modules', 'dist', 'coverage', '.git', 'sbin'].includes(item)) {
+          traverse(fullPath);
+        }
+      } else if (stat.isFile()) {
+        const ext = path.extname(item);
+        if (extensions.includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  }
+
+  traverse(dir);
+  return files;
+}
+
+// Extract translation keys from file content
+function extractTranslationKeys(
+  content: string,
+  filePath: string
+): Array<{ key: string; line: number; context: string }> {
+  const results: Array<{ key: string; line: number; context: string }> = [];
+
+  // Regex patterns for t('...') or $t('...')
+  const patterns = [/\bt\(['"]([^'"]+)['"]\)/g, /\$t\(['"]([^'"]+)['"]\)/g, /this\.\$t\(['"]([^'"]+)['"]\)/g];
+
+  const lines = content.split('\n');
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+
+    for (const pattern of patterns) {
+      let match;
+      const regex = new RegExp(pattern);
+
+      while ((match = regex.exec(line)) !== null) {
+        const key = match[1];
+        if (!key) continue;
+
+        results.push({
+          key,
+          line: i + 1,
+          context: line.trim()
+        });
+      }
+    }
+  }
+
+  return results;
+}
+
+// Main function
+function checkMissingTranslations() {
+  console.log('🔍 Checking for missing translation keys...\n');
+
+  // Load all translation keys from en-CA.json
+  const localeKeys = loadLocaleKeys();
+  console.log(`✅ Loaded ${localeKeys.size} translation keys from en-CA.json\n`);
+
+  // Find all Vue and TypeScript files
+  const files = findFiles(srcDir, ['.vue', '.ts']);
+  console.log(`📁 Found ${files.length} files to check\n`);
+
+  // Track missing translations
+  const missingTranslations: MissingTranslation[] = [];
+  const usedKeys = new Set<string>();
+
+  // Check each file
+  for (const file of files) {
+    const content = fs.readFileSync(file, 'utf-8');
+    const keys = extractTranslationKeys(content, file);
+
+    for (const { key, line, context } of keys) {
+      usedKeys.add(key);
+
+      if (!localeKeys.has(key)) {
+        missingTranslations.push({
+          file: path.relative(projectRoot, file),
+          line,
+          key,
+          context
+        });
+      }
+    }
+  }
+
+  // Find unused translations
+  const unusedTranslations: string[] = [];
+  for (const localeKey of localeKeys) {
+    if (!usedKeys.has(localeKey)) {
+      unusedTranslations.push(localeKey);
+    }
+  }
+
+  // Display results
+  console.log('═══════════════════════════════════════════════════════════════\n');
+  console.log(`📊 Summary:`);
+  console.log(`   Total translation keys defined: ${localeKeys.size}`);
+  console.log(`   Total translation keys used: ${usedKeys.size}`);
+  console.log(`   Missing translation keys: ${missingTranslations.length}`);
+  console.log(`   Unused translation keys: ${unusedTranslations.length}`);
+  console.log('\n═══════════════════════════════════════════════════════════════\n');
+
+  let hasIssues = false;
+
+  if (missingTranslations.length > 0) {
+    hasIssues = true;
+    console.log('❌ Missing Translation Keys:\n');
+
+    // Group by file
+    const byFile = new Map<string, MissingTranslation[]>();
+    for (const missing of missingTranslations) {
+      if (!byFile.has(missing.file)) {
+        byFile.set(missing.file, []);
+      }
+      byFile.get(missing.file)!.push(missing);
+    }
+
+    // Display grouped by file
+    for (const [file, items] of byFile) {
+      console.log(`\n📄 ${file}`);
+      for (const item of items) {
+        console.log(`   Line ${item.line}: ${item.key}`);
+        console.log(`   Context: ${item.context}`);
+        console.log('');
+      }
+    }
+
+    // Display unique missing keys
+    const uniqueMissing = [...new Set(missingTranslations.map((m) => m.key))];
+    console.log('\n═══════════════════════════════════════════════════════════════\n');
+    console.log('📋 Unique Missing Keys:\n');
+    uniqueMissing.sort().forEach((key) => console.log(`   - ${key}`));
+    console.log('\n═══════════════════════════════════════════════════════════════\n');
+  }
+
+  if (unusedTranslations.length > 0) {
+    console.log('⚠️  Unused Translation Keys:\n');
+    console.log('The following keys are defined in en-CA.json but not used anywhere:\n');
+    unusedTranslations.sort().forEach((key) => console.log(`   - ${key}`));
+    console.log('\n═══════════════════════════════════════════════════════════════\n');
+  }
+
+  if (!hasIssues && unusedTranslations.length === 0) {
+    console.log('✅ All translation keys are defined and used!\n');
+    process.exit(0);
+  } else if (hasIssues) {
+    process.exit(1);
+  } else {
+    console.log('✅ All used translation keys are defined!\n');
+    console.log('💡 Tip: Consider removing unused translation keys to keep the codebase clean.\n');
+    process.exit(0);
+  }
+}
+
+// Run the check
+checkMissingTranslations();