@arcpkg/initiator 0.0.1-beta.0.1

package/js/intl.js

@@ -0,0 +1,287 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import * as ts from 'typescript';
+import { Pajo, } from '@arcpkg/pajo';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function discoverLocales(localesDir) {
+    try {
+        const found = fs.readdirSync(localesDir)
+            .filter((file) => file.endsWith('.json'))
+            .map((file) => file.replace(/\.json$/, ''))
+            .sort();
+        if (found.length > 0)
+            return found;
+    }
+    catch (error) {
+    }
+    return ['en', 'fr'];
+}
+export class TranslationGenerator {
+    config;
+    keys = [];
+    modules = new Set();
+    importedModules = new Set();
+    constructor(config = {}, dirname = __dirname) {
+        this.config = {
+            srcDir: config.srcDir || Pajo.join(dirname, 'src') || '',
+            supportedLocales: config.supportedLocales || discoverLocales(config.localesDir || Pajo.join(dirname, 'src\\locales') || ''),
+            outputFile: config.outputFile || Pajo.join(dirname, 'src\\auto-intl.ts') || '',
+            modulesDir: config.modulesDir || Pajo.join(dirname, 'src\\modules') || '',
+            localesDir: config.localesDir || Pajo.join(dirname, 'src\\locales') || ''
+        };
+        console.log(`--> this.config:: `, this.config);
+    }
+    async generate() {
+        console.log('🔍 Scanning source files for translation keys...');
+        const srcFiles = this.findSourceFiles(this.config.srcDir);
+        for (const file of srcFiles) {
+            await this.extractKeysFromFile(file);
+        }
+        await this.discoverModules();
+        await this.generateAutoIntlFile();
+        console.log(`✅ Generated ${this.config.outputFile} with ${this.keys.length} translation keys`);
+        console.log(`📦 Found modules: ${Array.from(this.modules).join(', ')}`);
+    }
+    findSourceFiles(dir) {
+        const files = [];
+        try {
+            const items = fs.readdirSync(dir, { withFileTypes: true });
+            for (const item of items) {
+                const fullPath = path.join(dir, item.name);
+                if (item.name === 'node_modules' ||
+                    item.name === 'dist' ||
+                    item.name === 'build' ||
+                    fullPath === this.config.outputFile) {
+                    continue;
+                }
+                if (item.isDirectory()) {
+                    files.push(...this.findSourceFiles(fullPath));
+                }
+                else if (item.isFile()) {
+                    const ext = path.extname(item.name).toLowerCase();
+                    if (['.ts', '.tsx', '.js', '.jsx'].includes(ext)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error scanning directory ${dir}:`, error);
+        }
+        return files;
+    }
+    async extractKeysFromFile(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const sourceFile = ts.createSourceFile(path.basename(filePath), content, ts.ScriptTarget.Latest, true);
+            this.visitNode(sourceFile, filePath);
+        }
+        catch (error) {
+            console.error(`Error processing file ${filePath}:`, error);
+        }
+    }
+    visitNode(node, filePath) {
+        if (ts.isCallExpression(node)) {
+            const expression = node.expression;
+            if (ts.isIdentifier(expression) && expression.text === 't') {
+                this.extractTFunctionCall(node, filePath);
+            }
+            if (ts.isIdentifier(expression) && expression.text === 'useTranslation') {
+                this.extractUseTranslationHook(node, filePath);
+            }
+        }
+        ts.forEachChild(node, (child) => this.visitNode(child, filePath));
+    }
+    extractTFunctionCall(node, filePath) {
+        try {
+            const args = node.arguments;
+            if (args.length === 0)
+                return;
+            const keyArg = args[0];
+            let key = '';
+            if (ts.isStringLiteral(keyArg)) {
+                key = keyArg.text;
+            }
+            else if (ts.isTemplateLiteral(keyArg)) {
+                const text = keyArg.getText();
+                const templateParts = text.match(/`([^`]*)`/);
+                if (templateParts && templateParts[1]) {
+                    key = templateParts[1].split('${')[0].trim();
+                }
+            }
+            else if (ts.isNoSubstitutionTemplateLiteral(keyArg)) {
+                key = keyArg.text;
+            }
+            if (!key)
+                return;
+            const translationKey = { key };
+            // Extract module name from options (third argument)
+            if (args.length >= 3 && ts.isObjectLiteralExpression(args[2])) {
+                args[2].properties.forEach(property => {
+                    if (ts.isPropertyAssignment(property)) {
+                        const propertyName = property.name.getText();
+                        if (propertyName === 'moduleName' && ts.isStringLiteral(property.initializer)) {
+                            translationKey.module = property.initializer.text;
+                        }
+                        else if (propertyName === 'defaultValue' && ts.isStringLiteral(property.initializer)) {
+                            translationKey.defaultValue = property.initializer.text;
+                        }
+                        else if (propertyName === 'context' && ts.isStringLiteral(property.initializer)) {
+                            translationKey.context = property.initializer.text;
+                        }
+                        else if (propertyName === 'count') {
+                            translationKey.count = true;
+                        }
+                    }
+                });
+            }
+            // Try to infer module from file path
+            if (!translationKey.module) {
+                const moduleMatch = filePath.match(/modules[\\\/]([^\\\/]+)/);
+                if (moduleMatch) {
+                    translationKey.module = moduleMatch[1];
+                }
+            }
+            // Add to keys if not already present
+            const existingKey = this.keys.find(k => k.key === translationKey.key &&
+                k.module === translationKey.module);
+            if (!existingKey) {
+                this.keys.push(translationKey);
+            }
+        }
+        catch (error) {
+            console.error(`Error extracting t() call in ${filePath}:`, error);
+        }
+    }
+    extractUseTranslationHook(node, filePath) {
+        try {
+            const args = node.arguments;
+            if (args.length > 0 && ts.isStringLiteral(args[0])) {
+                const moduleName = args[0].text;
+                // Add to imported modules
+                this.importedModules.add(moduleName);
+                // Also add to modules set
+                this.modules.add(moduleName);
+            }
+        }
+        catch (error) {
+            console.error(`Error extracting useTranslation hook in ${filePath}:`, error);
+        }
+    }
+    async discoverModules() {
+        try {
+            // Check if modules directory exists
+            if (!fs.existsSync(this.config.modulesDir)) {
+                return;
+            }
+            // List all modules
+            const moduleDirs = fs.readdirSync(this.config.modulesDir, { withFileTypes: true })
+                .filter(dirent => dirent.isDirectory())
+                .map(dirent => dirent.name);
+            // Check each module for locales directory
+            for (const moduleName of moduleDirs) {
+                const localesPath = path.join(this.config.modulesDir, moduleName, 'locales');
+                if (fs.existsSync(localesPath)) {
+                    // Check if any locale file exists
+                    const localeFiles = fs.readdirSync(localesPath)
+                        .filter(file => file.endsWith('.json'))
+                        .map(file => file.replace('.json', ''));
+                    // Only add module if it has locale files
+                    if (localeFiles.length > 0) {
+                        this.modules.add(moduleName);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error discovering modules:', error);
+        }
+    }
+    async generateAutoIntlFile() {
+        const outputDir = path.dirname(this.config.outputFile);
+        // Create output directory if it doesn't exist
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        const content = this.generateFileContent();
+        fs.writeFileSync(this.config.outputFile, content, 'utf-8');
+    }
+    generateFileContent() {
+        const { supportedLocales } = this.config;
+        // Sort modules alphabetically
+        const sortedModules = Array.from(this.modules).sort();
+        // Check if base locales directory exists
+        const baseLocalesExist = fs.existsSync(this.config.localesDir);
+        // Generate base locales imports
+        const baseImports = supportedLocales.map(locale => {
+            const importPath = `./locales/${locale}.json`;
+            if (baseLocalesExist) {
+                return `  '${locale}': (() => import('${importPath}').then(module => module.default || module))`;
+            }
+            else {
+                return `  '${locale}': (() => Promise.resolve({}))`;
+            }
+        }).join(',\n');
+        // Generate modules imports
+        const modulesImports = sortedModules.map(moduleName => {
+            const localesPath = path.join(this.config.modulesDir, moduleName, 'locales');
+            const moduleLocalesExist = fs.existsSync(localesPath);
+            const moduleLocales = supportedLocales.map(locale => {
+                const importPath = `./modules/${moduleName}/locales/${locale}.json`;
+                if (moduleLocalesExist) {
+                    return `    '${locale}': (() => import('${importPath}').then(module => module.default || module))`;
+                }
+                else {
+                    return `    '${locale}': (() => Promise.resolve({}))`;
+                }
+            }).join(',\n');
+            return `  '${moduleName}': {\n${moduleLocales}\n  }`;
+        }).join(',\n');
+        // Generate the TypeScript content
+        return `export const translations = {
+  'base': {
+    ${baseImports}
+  },
+  'modules': {
+    ${modulesImports.length > 0 ? modulesImports : '    // No modules with translations found'}
+  }
+};
+
+export default translations;`;
+    }
+    generateTypeDefinitions() {
+        if (this.keys.length === 0) {
+            return 'string';
+        }
+        // Group keys by module
+        const keysByModule = {};
+        this.keys.forEach(key => {
+            const module = key.module || 'core';
+            if (!keysByModule[module]) {
+                keysByModule[module] = [];
+            }
+            keysByModule[module].push(key.key);
+        });
+        // Generate union types for each module
+        const moduleTypes = Object.entries(keysByModule).map(([module, keys]) => {
+            const keyUnion = keys
+                .filter((value, index, self) => self.indexOf(value) === index) // Remove duplicates
+                .map(k => `"${k}"`)
+                .join(' | ');
+            return module === 'core' ? keyUnion : `${module}:${keyUnion}`;
+        });
+        return moduleTypes.join(' | ');
+    }
+}
+async function TranslationInitiator(dirname = __dirname) {
+    const config = {};
+    const generator = new TranslationGenerator(config, dirname);
+    generator.generate().then(() => {
+        console.log('🎉 Translation generation completed successfully!');
+    }).catch((err) => {
+        console.error('❌ Failed to generate translations: ', err);
+    });
+}
+export default TranslationInitiator;