@leejungkiin/awkit 1.7.1 → 1.7.5

package/scripts/i18n-helper.js

@@ -0,0 +1,381 @@
+const fs = require('fs');
+const path = require('path');
+
+const C = {
+    cyan: '\x1b[36m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    gray: '\x1b[90m',
+    bold: '\x1b[1m',
+    reset: '\x1b[0m'
+};
+
+function log(msg) { console.log(msg); }
+function ok(msg) { log(`${C.green}✓ ${msg}${C.reset}`); }
+function warn(msg) { log(`${C.yellow}⚠ ${msg}${C.reset}`); }
+function err(msg) { log(`${C.red}✗ ${msg}${C.reset}`); }
+function dim(msg) { log(`${C.gray}${msg}${C.reset}`); }
+
+// Helper to set nested property in object (like lodash.set)
+function setNested(obj, pathStr, value) {
+    const parts = pathStr.split('.');
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (current[part] === undefined || typeof current[part] !== 'object') {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    current[parts[parts.length - 1]] = value;
+}
+
+// Helper to get nested property in object
+function getNested(obj, pathStr) {
+    const parts = pathStr.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined) return undefined;
+        current = current[part];
+    }
+    return current;
+}
+
+// Recursively find all nested keys and values in an object
+function flattenObject(obj, prefix = '') {
+    let results = {};
+    for (const k in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, k)) {
+            const keyName = prefix ? `${prefix}.${k}` : k;
+            if (obj[k] !== null && typeof obj[k] === 'object' && !Array.isArray(obj[k])) {
+                Object.assign(results, flattenObject(obj[k], keyName));
+            } else {
+                results[keyName] = obj[k];
+            }
+        }
+    }
+    return results;
+}
+
+// Format Javascript object as clean JS/TS string with sorted keys
+function formatJsObject(obj, indent = 2) {
+    const spaces = ' '.repeat(indent);
+    if (Array.isArray(obj)) {
+        return '[\n' + obj.map(item => spaces + formatJsObject(item, indent + 2)).join(',\n') + '\n' + ' '.repeat(indent - 2) + ']';
+    } else if (obj !== null && typeof obj === 'object') {
+        const keys = Object.keys(obj).sort();
+        const lines = keys.map(k => {
+            const keyStr = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k) ? k : JSON.stringify(k);
+            return `${spaces}${keyStr}: ${formatJsObject(obj[k], indent + 2)}`;
+        });
+        return '{\n' + lines.join(',\n') + '\n' + ' '.repeat(indent - 2) + '}';
+    } else {
+        return JSON.stringify(obj);
+    }
+}
+
+// Find translation files in target directories, avoiding heavy system folders
+function findTranslationFiles(dir) {
+    const filesList = [];
+    const ignoreList = ['node_modules', '.git', '.gitnexus', 'dist', 'build', '.expo', 'ios', 'android', 'web-build'];
+
+    function traverse(currentDir) {
+        let list;
+        try {
+            list = fs.readdirSync(currentDir);
+        } catch (_) {
+            return;
+        }
+
+        for (const file of list) {
+            const absPath = path.join(currentDir, file);
+            let stat;
+            try {
+                stat = fs.statSync(absPath);
+            } catch (_) {
+                continue;
+            }
+
+            if (stat.isDirectory()) {
+                if (ignoreList.includes(file)) continue;
+                traverse(absPath);
+            } else if (stat.isFile()) {
+                const ext = path.extname(file).toLowerCase();
+                const nameLower = file.toLowerCase();
+
+                // Look for translations.* or locale files like en.json, vi.json
+                const isTranslationFile = 
+                    (nameLower.includes('translation') && (ext === '.json' || ext === '.ts' || ext === '.js')) ||
+                    (ext === '.json' && (nameLower === 'en.json' || nameLower === 'vi.json' || nameLower === 'ja.json'));
+
+                if (isTranslationFile) {
+                    filesList.push(absPath);
+                }
+            }
+        }
+    }
+
+    traverse(dir);
+    return filesList;
+}
+
+// Read and parse translation file safely
+function readTranslationFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const ext = path.extname(filePath).toLowerCase();
+
+    if (ext === '.json') {
+        try {
+            return { type: 'json', data: JSON.parse(content), raw: content };
+        } catch (e) {
+            throw new Error(`Failed to parse JSON file ${filePath}: ${e.message}`);
+        }
+    } else if (ext === '.ts' || ext === '.js') {
+        // Find the outer curly braces block
+        const braceStart = content.indexOf('{');
+        const braceEnd = content.lastIndexOf('}');
+        if (braceStart === -1 || braceEnd === -1 || braceEnd < braceStart) {
+            throw new Error(`Could not locate object braces in JS/TS file: ${filePath}`);
+        }
+
+        const objectStr = content.substring(braceStart, braceEnd + 1);
+        try {
+            // Safe evaluation of object content
+            const data = new Function(`return (${objectStr})`)();
+            return {
+                type: 'js',
+                data,
+                prefix: content.substring(0, braceStart),
+                suffix: content.substring(braceEnd + 1),
+                raw: content
+            };
+        } catch (e) {
+            throw new Error(`Failed to parse JS/TS object in ${filePath}: ${e.message}`);
+        }
+    }
+
+    throw new Error(`Unsupported translation file type: ${ext}`);
+}
+
+// Write translation file safely
+function writeTranslationFile(filePath, fileInfo) {
+    if (fileInfo.type === 'json') {
+        // Sort keys recursively
+        const sorted = sortObjectKeys(fileInfo.data);
+        fs.writeFileSync(filePath, JSON.stringify(sorted, null, 2) + '\n', 'utf8');
+    } else if (fileInfo.type === 'js') {
+        const sorted = sortObjectKeys(fileInfo.data);
+        const formatted = formatJsObject(sorted);
+        fs.writeFileSync(filePath, `${fileInfo.prefix}${formatted}${fileInfo.suffix}`, 'utf8');
+    }
+}
+
+// Sort object keys recursively
+function sortObjectKeys(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map(sortObjectKeys);
+    } else if (obj !== null && typeof obj === 'object') {
+        const sorted = {};
+        Object.keys(obj).sort().forEach(key => {
+            sorted[key] = sortObjectKeys(obj[key]);
+        });
+        return sorted;
+    }
+    return obj;
+}
+
+// CLI implementation
+async function cmdI18n(args) {
+    const subCmd = args[0] || 'help';
+
+    if (subCmd === 'help' || subCmd === '--help' || subCmd === '-h') {
+        log('');
+        log(`${C.cyan}${C.bold}🌐 awkit i18n — Language & Translation Workflow Helper${C.reset}`);
+        log(`${C.gray}${'─'.repeat(56)}${C.reset}`);
+        log(`Manage your localization and translation files cleanly.`);
+        log('');
+        log(`${C.bold}Commands:${C.reset}`);
+        log(`  ${C.green}add${C.reset} --key <key> [--en <val>] [--vi <val>] ...`);
+        log(`      Add a translation key with values across files.`);
+        log(`  ${C.green}search${C.reset} <query>  (or find)`);
+        log(`      Search for translation keys or values containing query.`);
+        log(`  ${C.green}sync${C.reset}`);
+        log(`      Alphabetically sort and synchronize keys across all translation files.`);
+        log(`  ${C.green}list${C.reset}`);
+        log(`      List all translations mapped in the project.`);
+        log('');
+        log(`${C.bold}Examples:${C.reset}`);
+        log(`  awkit i18n add --key "auth.login.title" --en "Log In" --vi "Đăng nhập"`);
+        log(`  awkit i18n search "Welcome"`);
+        log('');
+        return;
+    }
+
+    const cwd = process.cwd();
+    
+    // Read files configured in .project-identity or auto-detect
+    let configFiles = [];
+    const identityPath = path.join(cwd, '.project-identity');
+    if (fs.existsSync(identityPath)) {
+        try {
+            const identity = JSON.parse(fs.readFileSync(identityPath, 'utf8'));
+            if (identity.i18n && Array.isArray(identity.i18n.files)) {
+                configFiles = identity.i18n.files.map(f => path.resolve(cwd, f));
+            }
+        } catch (_) {}
+    }
+
+    const files = configFiles.length > 0 ? configFiles : findTranslationFiles(cwd);
+
+    if (files.length === 0) {
+        err('No translation files found in this repository.');
+        dim('Either configure "i18n.files" in .project-identity or place translation files matching *translation*.{json,ts,js} or en.json/vi.json.');
+        return;
+    }
+
+    switch (subCmd) {
+        case 'add': {
+            // Parse arguments
+            let key = '';
+            const translations = {};
+            
+            for (let i = 1; i < args.length; i++) {
+                if (args[i] === '--key') {
+                    key = args[++i];
+                } else if (args[i].startsWith('--')) {
+                    const lang = args[i].substring(2);
+                    translations[lang] = args[++i];
+                } else if (args[i].includes(':')) {
+                    // Alternative syntax: en:Hello
+                    const parts = args[i].split(':');
+                    const lang = parts[0];
+                    const val = parts.slice(1).join(':');
+                    translations[lang] = val;
+                }
+            }
+
+            if (!key) {
+                err('Missing translation key. Specify using --key <key_name>');
+                return;
+            }
+
+            if (Object.keys(translations).length === 0) {
+                err('No translations specified. E.g. --en "Hello" --vi "Xin chào"');
+                return;
+            }
+
+            info(`Adding key "${key}" to translation files...`);
+            
+            for (const file of files) {
+                const basename = path.basename(file);
+                const fileLang = basename.split('.')[0].toLowerCase(); // e.g. en, vi, translations
+                
+                try {
+                    const fileInfo = readTranslationFile(file);
+                    
+                    // Match translation value. If file name is specific like en.json or vi.json, inject specific lang.
+                    // If it is translations.ts, inject nested object languages.
+                    if (fileLang === 'en' || fileLang === 'vi') {
+                        const val = translations[fileLang] || translations['en'] || Object.values(translations)[0];
+                        setNested(fileInfo.data, key, val);
+                    } else {
+                        // Mixed translation file (e.g. translations.ts), set language key paths
+                        for (const lang in translations) {
+                            if (fileInfo.data[lang] !== undefined) {
+                                setNested(fileInfo.data[lang], key, translations[lang]);
+                            } else {
+                                // Fallback directly on root
+                                setNested(fileInfo.data, `${lang}.${key}`, translations[lang]);
+                            }
+                        }
+                    }
+                    
+                    writeTranslationFile(file, fileInfo);
+                    ok(`Updated ${basename}`);
+                } catch (e) {
+                    err(`Failed updating ${basename}: ${e.message}`);
+                }
+            }
+            break;
+        }
+
+        case 'search':
+        case 'find': {
+            const query = args.slice(1).join(' ').toLowerCase();
+            if (!query) {
+                err('Please specify a query to search.');
+                return;
+            }
+
+            log(`\n🔍 Searching for "${query}" in translations...`);
+            log(`${C.gray}${'─'.repeat(56)}${C.reset}`);
+
+            let matchesFound = 0;
+            for (const file of files) {
+                try {
+                    const fileInfo = readTranslationFile(file);
+                    const flattened = flattenObject(fileInfo.data);
+                    
+                    for (const key in flattened) {
+                        const val = String(flattened[key]);
+                        if (key.toLowerCase().includes(query) || val.toLowerCase().includes(query)) {
+                            log(`  [${C.cyan}${path.basename(file)}${C.reset}] ${C.green}${key}${C.reset}: "${val}"`);
+                            matchesFound++;
+                        }
+                    }
+                } catch (e) {
+                    err(`Error scanning ${path.basename(file)}: ${e.message}`);
+                }
+            }
+            if (matchesFound === 0) {
+                warn('No matches found.');
+            } else {
+                log(`\nFound ${matchesFound} matches.`);
+            }
+            break;
+        }
+
+        case 'sync': {
+            info('Synchronizing and formatting all translation files...');
+            for (const file of files) {
+                try {
+                    const fileInfo = readTranslationFile(file);
+                    writeTranslationFile(file, fileInfo);
+                    ok(`Synced & Sorted ${path.basename(file)}`);
+                } catch (e) {
+                    err(`Failed to sync ${path.basename(file)}: ${e.message}`);
+                }
+            }
+            break;
+        }
+
+        case 'list': {
+            log(`\n📋 Listing all translation entries:`);
+            log(`${C.gray}${'─'.repeat(56)}${C.reset}`);
+            for (const file of files) {
+                try {
+                    const fileInfo = readTranslationFile(file);
+                    const flattened = flattenObject(fileInfo.data);
+                    log(`\n${C.cyan}${path.basename(file)}${C.reset}:`);
+                    for (const key in flattened) {
+                        log(`  ${C.green}${key}${C.reset}: "${flattened[key]}"`);
+                    }
+                } catch (e) {
+                    err(`Error reading ${path.basename(file)}: ${e.message}`);
+                }
+            }
+            break;
+        }
+
+        default:
+            err(`Unknown command: ${subCmd}`);
+            break;
+    }
+}
+
+function info(msg) { log(`${C.cyan}ℹ ${msg}${C.reset}`); }
+
+module.exports = {
+    cmdI18n
+};