i18ntk 1.0.0

package/dev/debug/find-extra-keys.js

@@ -0,0 +1,68 @@
+const fs = require('fs');
+const path = require('path');
+
+// Function to get all keys from nested object
+function getAllKeys(obj, prefix = '') {
+    let keys = [];
+    
+    for (const key in obj) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        
+        if (typeof obj[key] === 'object' && obj[key] !== null) {
+            if (Array.isArray(obj[key])) {
+                keys.push(fullKey);
+                obj[key].forEach((item, index) => {
+                    if (typeof item === 'object' && item !== null) {
+                        keys = keys.concat(getAllKeys(item, `${fullKey}[${index}]`));
+                    }
+                });
+            } else {
+                keys = keys.concat(getAllKeys(obj[key], fullKey));
+            }
+        } else {
+            keys.push(fullKey);
+        }
+    }
+    
+    return keys;
+}
+
+// Main function to find extra keys
+function findExtraKeys() {
+    const localesDir = './ui-locales';
+    const enPath = path.join(localesDir, 'en.json');
+    
+    // Load English reference
+    const enData = JSON.parse(fs.readFileSync(enPath, 'utf8'));
+    const enKeys = getAllKeys(enData);
+    
+    console.log(`📋 English reference has ${enKeys.length} keys`);
+    
+    // Check other files
+    const files = ['es.json', 'fr.json', 'ja.json', 'ru.json', 'zh.json'];
+    
+    files.forEach(file => {
+        const filePath = path.join(localesDir, file);
+        try {
+            const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+            const keys = getAllKeys(data);
+            
+            const extraKeys = keys.filter(key => !enKeys.includes(key));
+            
+            console.log(`\n🔍 ${file}:`);
+            console.log(`   Total keys: ${keys.length}`);
+            console.log(`   Extra keys: ${extraKeys.length}`);
+            
+            if (extraKeys.length > 0) {
+                console.log(`   Extra keys list:`);
+                extraKeys.forEach(key => {
+                    console.log(`     - ${key}`);
+                });
+            }
+        } catch (error) {
+            console.log(`❌ Error reading ${file}: ${error.message}`);
+        }
+    });
+}
+
+findExtraKeys();

package/dev/debug/normalize-locales.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+
+/**
+ * normalize-locales.js
+ *
+ * Recursively aligns the structure and nesting of all locale files to match en.json.
+ * - Fills missing keys with a placeholder (e.g., "[MISSING]").
+ * - Reports extra keys not present in en.json.
+ * - Optionally can fix files in-place or just report (dry run).
+ *
+ * Usage:
+ *   node normalize-locales.js [--dry-run]
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const LOCALES_DIR = path.resolve(__dirname, '../../ui-locales');
+const REFERENCE_LANG = 'en.json';
+const PLACEHOLDER = '[NOT TRANSLATED]';
+const DRY_RUN = process.argv.includes('--dry-run');
+
+function loadJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    console.error(`Failed to parse ${filePath}:`, e.message);
+    return null;
+  }
+}
+
+function hasDuplicateKeys(jsonString) {
+  const keyStack = [];
+  const keySetStack = [new Set()];
+  let inString = false, key = '', expectingKey = false, depth = 0;
+  for (let i = 0; i < jsonString.length; i++) {
+    const char = jsonString[i];
+    if (char === '"' && jsonString[i - 1] !== '\\') {
+      inString = !inString;
+      if (!inString && expectingKey) {
+        if (keySetStack[depth].has(key)) return true;
+        keySetStack[depth].add(key);
+        key = '';
+        expectingKey = false;
+      }
+      continue;
+    }
+    if (inString) {
+      if (expectingKey) key += char;
+      continue;
+    }
+    if (char === '{') {
+      depth++;
+      keySetStack[depth] = new Set();
+    } else if (char === '}') {
+      keySetStack.pop();
+      depth--;
+    } else if (char === ':' && !inString) {
+      expectingKey = false;
+    } else if (char === ',' && !inString) {
+      expectingKey = true;
+    } else if (!inString && expectingKey && /[\w\d_]/.test(char)) {
+      key += char;
+    }
+  }
+  return false;
+}
+
+function saveJson(filePath, data) {
+  const jsonString = JSON.stringify(data, null, 2);
+  if (hasDuplicateKeys(jsonString)) {
+    console.error(`Duplicate keys detected in ${filePath}. File not saved.`);
+    return;
+  }
+  fs.writeFileSync(filePath, jsonString, 'utf8');
+}
+
+function normalizeObject(ref, target, pathArr = [], report = {missing: [], extra: []}) {
+  // Add missing keys from ref to target
+  for (const key of Object.keys(ref)) {
+    if (!(key in target)) {
+      target[key] = typeof ref[key] === 'object' && ref[key] !== null ? {} : PLACEHOLDER;
+      report.missing.push([...pathArr, key].join('.'));
+    }
+    if (typeof ref[key] === 'object' && ref[key] !== null) {
+      if (typeof target[key] !== 'object' || target[key] === null) {
+        target[key] = {};
+      }
+      normalizeObject(ref[key], target[key], [...pathArr, key], report);
+    }
+  }
+  // Find extra keys in target not in ref
+  for (const key of Object.keys(target)) {
+    if (!(key in ref)) {
+      report.extra.push([...pathArr, key].join('.'));
+    }
+  }
+  return report;
+}
+
+function replaceMissingPlaceholders(obj) {
+  for (const key in obj) {
+    if (typeof obj[key] === 'object' && obj[key] !== null) {
+      replaceMissingPlaceholders(obj[key]);
+    } else if (obj[key] === '[MISSING]') {
+      obj[key] = PLACEHOLDER;
+    }
+  }
+}
+
+function main() {
+  const files = fs.readdirSync(LOCALES_DIR).filter(f => f.endsWith('.json'));
+  const refPath = path.join(LOCALES_DIR, REFERENCE_LANG);
+  const refJson = loadJson(refPath);
+  if (!refJson) {
+    console.error('Reference language file not found or invalid:', refPath);
+    process.exit(1);
+  }
+
+  for (const file of files) {
+    if (file === REFERENCE_LANG) continue;
+    const filePath = path.join(LOCALES_DIR, file);
+    const targetJson = loadJson(filePath);
+    if (!targetJson) {
+      console.warn(`Skipping invalid JSON: ${file}`);
+      continue;
+    }
+    const report = normalizeObject(refJson, targetJson);
+    replaceMissingPlaceholders(targetJson);
+    if (report.missing.length || report.extra.length) {
+      console.log(`\n[${file}]`);
+      if (report.missing.length) {
+        console.log('  Missing keys:');
+        report.missing.forEach(k => console.log('    -', k));
+      }
+      if (report.extra.length) {
+        console.log('  Extra keys:');
+        report.extra.forEach(k => console.log('    -', k));
+      }
+      if (!DRY_RUN) {
+        saveJson(filePath, targetJson);
+        console.log('  File updated.');
+      } else {
+        console.log('  (Dry run: no changes made)');
+      }
+    } else {
+      console.log(`\n[${file}] No changes needed.`);
+    }
+  }
+  console.log('\nNormalization complete.');
+}
+
+main();

package/dev/debug/refactor-locales.js

@@ -0,0 +1,240 @@
+const fs = require('fs');
+const path = require('path');
+
+// Configuration
+const LOCALES_DIR = path.join(__dirname, '../../ui-locales');
+const REFERENCE_FILE = 'en.json';
+const PLACEHOLDER = '[NOT TRANSLATED]';
+
+/**
+ * Load and parse JSON file
+ */
+function loadJson(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        return JSON.parse(content);
+    } catch (error) {
+        console.error(`Error loading ${filePath}:`, error.message);
+        return null;
+    }
+}
+
+/**
+ * Save JSON file with proper formatting
+ */
+function saveJson(filePath, data) {
+    try {
+        const jsonString = JSON.stringify(data, null, 2);
+        fs.writeFileSync(filePath, jsonString, 'utf8');
+        return true;
+    } catch (error) {
+        console.error(`Error saving ${filePath}:`, error.message);
+        return false;
+    }
+}
+
+/**
+ * Get all translation keys from an object recursively
+ */
+function getAllKeys(obj, prefix = '') {
+    const keys = [];
+    
+    for (const [key, value] of Object.entries(obj)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            keys.push(...getAllKeys(value, fullKey));
+        } else {
+            keys.push(fullKey);
+        }
+    }
+    
+    return keys;
+}
+
+/**
+ * Get value from nested object using dot notation
+ */
+function getValue(obj, path) {
+    return path.split('.').reduce((current, key) => {
+        return current && current[key] !== undefined ? current[key] : undefined;
+    }, obj);
+}
+
+/**
+ * Set value in nested object using dot notation
+ */
+function setValue(obj, path, value) {
+    const keys = path.split('.');
+    const lastKey = keys.pop();
+    
+    const target = keys.reduce((current, key) => {
+        if (!current[key] || typeof current[key] !== 'object') {
+            current[key] = {};
+        }
+        return current[key];
+    }, obj);
+    
+    target[lastKey] = value;
+}
+
+/**
+ * Create a properly structured object based on reference structure
+ */
+function createStructuredObject(referenceObj, sourceObj = {}) {
+    const result = {};
+    
+    function processObject(refObj, srcObj, targetObj) {
+        for (const [key, value] of Object.entries(refObj)) {
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                targetObj[key] = {};
+                processObject(value, srcObj[key] || {}, targetObj[key]);
+            } else {
+                // Try to find the value in the source object
+                const sourceValue = srcObj[key];
+                if (sourceValue !== undefined && sourceValue !== PLACEHOLDER) {
+                    targetObj[key] = sourceValue;
+                } else {
+                    // Try to find it anywhere in the source object using dot notation
+                    const allKeys = getAllKeys(srcObj);
+                    const matchingKey = allKeys.find(k => k.endsWith(`.${key}`) || k === key);
+                    
+                    if (matchingKey) {
+                        const foundValue = getValue(srcObj, matchingKey);
+                        if (foundValue !== undefined && foundValue !== PLACEHOLDER) {
+                            targetObj[key] = foundValue;
+                        } else {
+                            targetObj[key] = PLACEHOLDER;
+                        }
+                    } else {
+                        targetObj[key] = PLACEHOLDER;
+                    }
+                }
+            }
+        }
+    }
+    
+    processObject(referenceObj, sourceObj, result);
+    return result;
+}
+
+/**
+ * Extract existing translations from a locale file
+ */
+function extractTranslations(localeObj) {
+    const translations = {};
+    
+    function extract(obj, prefix = '') {
+        for (const [key, value] of Object.entries(obj)) {
+            const fullKey = prefix ? `${prefix}.${key}` : key;
+            
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                extract(value, fullKey);
+            } else if (typeof value === 'string' && value !== PLACEHOLDER && value.trim() !== '') {
+                translations[fullKey] = value;
+            }
+        }
+    }
+    
+    extract(localeObj);
+    return translations;
+}
+
+/**
+ * Apply extracted translations to a structured object
+ */
+function applyTranslations(structuredObj, translations) {
+    for (const [key, value] of Object.entries(translations)) {
+        setValue(structuredObj, key, value);
+    }
+}
+
+/**
+ * Main refactoring function
+ */
+function refactorLocales() {
+    console.log('🔄 Starting locale files refactoring...');
+    
+    // Load reference file (en.json)
+    const referencePath = path.join(LOCALES_DIR, REFERENCE_FILE);
+    const referenceObj = loadJson(referencePath);
+    
+    if (!referenceObj) {
+        console.error('❌ Could not load reference file:', REFERENCE_FILE);
+        return;
+    }
+    
+    console.log('✅ Reference file loaded:', REFERENCE_FILE);
+    
+    // Get all locale files
+    const localeFiles = fs.readdirSync(LOCALES_DIR)
+        .filter(file => file.endsWith('.json') && file !== REFERENCE_FILE)
+        .sort();
+    
+    console.log(`📁 Found ${localeFiles.length} locale files to refactor:`, localeFiles.join(', '));
+    
+    let processedCount = 0;
+    
+    // Process each locale file
+    for (const file of localeFiles) {
+        console.log(`\n🔄 Processing ${file}...`);
+        
+        const filePath = path.join(LOCALES_DIR, file);
+        const localeObj = loadJson(filePath);
+        
+        if (!localeObj) {
+            console.error(`❌ Skipping ${file} due to load error`);
+            continue;
+        }
+        
+        // Extract existing translations
+        const existingTranslations = extractTranslations(localeObj);
+        console.log(`   📝 Extracted ${Object.keys(existingTranslations).length} existing translations`);
+        
+        // Create properly structured object
+        const structuredObj = createStructuredObject(referenceObj);
+        
+        // Apply existing translations
+        applyTranslations(structuredObj, existingTranslations);
+        
+        // Count translations vs placeholders
+        const allKeys = getAllKeys(structuredObj);
+        const translatedKeys = allKeys.filter(key => {
+            const value = getValue(structuredObj, key);
+            return value !== PLACEHOLDER && value !== '';
+        });
+        
+        console.log(`   ✅ Structure applied: ${translatedKeys.length}/${allKeys.length} keys translated`);
+        
+        // Save the refactored file
+        if (saveJson(filePath, structuredObj)) {
+            console.log(`   💾 ${file} refactored successfully`);
+            processedCount++;
+        } else {
+            console.error(`   ❌ Failed to save ${file}`);
+        }
+    }
+    
+    console.log(`\n🎉 Refactoring completed! Processed ${processedCount}/${localeFiles.length} files`);
+    
+    // Show final file sizes
+    console.log('\n📊 Final file sizes:');
+    const allFiles = [REFERENCE_FILE, ...localeFiles];
+    for (const file of allFiles) {
+        const filePath = path.join(LOCALES_DIR, file);
+        try {
+            const content = fs.readFileSync(filePath, 'utf8');
+            const lines = content.split('\n').length;
+            console.log(`   ${file}: ${lines} lines`);
+        } catch (error) {
+            console.log(`   ${file}: Error reading file`);
+        }
+    }
+}
+
+// Run the refactoring
+if (require.main === module) {
+    refactorLocales();
+}
+
+module.exports = { refactorLocales };

package/dev/debug/reorder-locales.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+/**
+ * reorder-locales.js
+ *
+ * Reorders and nests all locale files to match en.json, moving existing translations into the correct structure/order.
+ * Reports extra keys per file (does not delete them).
+ *
+ * Usage:
+ *   node reorder-locales.js [--dry-run]
+ */
+const fs = require('fs');
+const path = require('path');
+
+const LOCALES_DIR = path.resolve(__dirname, '../../ui-locales');
+const REFERENCE_LANG = 'en.json';
+const DRY_RUN = process.argv.includes('--dry-run');
+
+function loadJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    console.error(`Failed to parse ${filePath}:`, e.message);
+    return null;
+  }
+}
+
+function saveJson(filePath, data) {
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function reorderAndMerge(ref, target, pathArr = [], extraKeys = []) {
+  let result = Array.isArray(ref) ? [] : {};
+  // Add keys in reference order
+  for (const key of Object.keys(ref)) {
+    if (typeof ref[key] === 'object' && ref[key] !== null && !Array.isArray(ref[key])) {
+      result[key] = reorderAndMerge(ref[key], (target && target[key]) || {}, [...pathArr, key], extraKeys);
+    } else {
+      result[key] = (target && key in target) ? target[key] : '';
+    }
+  }
+  // Find extra keys in target not in ref
+  if (target && typeof target === 'object') {
+    for (const key of Object.keys(target)) {
+      if (!(key in ref)) {
+        extraKeys.push([...pathArr, key].join('.'));
+        result[key] = target[key]; // Keep extra keys at the end
+      }
+    }
+  }
+  return result;
+}
+
+function main() {
+  const files = fs.readdirSync(LOCALES_DIR).filter(f => f.endsWith('.json'));
+  const refPath = path.join(LOCALES_DIR, REFERENCE_LANG);
+  const refJson = loadJson(refPath);
+  if (!refJson) {
+    console.error('Reference language file not found or invalid:', refPath);
+    process.exit(1);
+  }
+  for (const file of files) {
+    if (file === REFERENCE_LANG) continue;
+    const filePath = path.join(LOCALES_DIR, file);
+    const targetJson = loadJson(filePath);
+    if (!targetJson) {
+      console.warn(`Skipping invalid JSON: ${file}`);
+      continue;
+    }
+    let extraKeys = [];
+    const reordered = reorderAndMerge(refJson, targetJson, [], extraKeys);
+    if (extraKeys.length) {
+      console.log(`\n[${file}] Extra keys not in en.json:`);
+      extraKeys.forEach(k => console.log('  -', k));
+    }
+    if (!DRY_RUN) {
+      saveJson(filePath, reordered);
+      console.log(`[${file}] File reordered and updated.`);
+    } else {
+      console.log(`[${file}] (Dry run: no changes made)`);
+    }
+  }
+  console.log('\nReordering complete.');
+}
+
+main();