@jsarc/initiator 0.0.0

package/intl.ts

@@ -0,0 +1,353 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import * as ts from 'typescript';
+import {
+  Pajo,
+} from '@jsarc/pajo';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export interface TranslationKey {
+    key: string;
+    module?: string;
+    defaultValue?: string;
+    context?: string;
+    count?: boolean;
+}
+
+export interface TranslationConfig {
+    srcDir: string;
+    supportedLocales: string[];
+    outputFile: string;
+    modulesDir: string;
+    localesDir: string;
+}
+
+export class TranslationGenerator {
+    private config: TranslationConfig;
+    private keys: TranslationKey[] = [];
+    private modules: Set<string> = new Set();
+    private importedModules: Set<string> = new Set();
+
+    constructor(
+        config: Partial<TranslationConfig> = {},
+        dirname: string | undefined = __dirname,
+    ) {
+        this.config = {
+            srcDir: config.srcDir || Pajo.join(dirname, 'src') || '',
+            supportedLocales: config.supportedLocales || ['en', 'fr'],
+            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);
+    }
+
+    public async generate(): Promise<void> {
+        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(', ')}`);
+    }
+
+    private findSourceFiles(dir: string): string[] {
+        const files: string[] = [];
+
+        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;
+    }
+
+    private async extractKeysFromFile(filePath: string): Promise<void> {
+        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);
+        }
+    }
+
+    private visitNode(node: ts.Node, filePath: string): void {
+        
+        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));
+    }
+
+    private extractTFunctionCall(node: ts.CallExpression, filePath: string): void {
+        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: 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);
+        }
+    }
+
+    private extractUseTranslationHook(node: ts.CallExpression, filePath: string): void {
+        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);
+        }
+    }
+
+    private async discoverModules(): Promise<void> {
+        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);
+        }
+    }
+
+    private async generateAutoIntlFile(): Promise<void> {
+        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');
+    }
+
+    private generateFileContent(): string {
+        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;`;
+    }
+
+    private generateTypeDefinitions(): string {
+        if (this.keys.length === 0) {
+            return 'string';
+        }
+
+        // Group keys by module
+        const keysByModule: Record<string, string[]> = {};
+
+        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: string | undefined = __dirname
+) {
+    const config: Partial<TranslationConfig> = {};
+
+    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;

package/js/config.js

@@ -0,0 +1,110 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { Pajo } from '@jsarc/pajo';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class ConfigGenerator {
+    config;
+    modules = new Set();
+    constructor(config = {}, dirname = __dirname) {
+        this.config = {
+            srcDir: config.srcDir || Pajo.join(dirname, 'src') || '',
+            outputFile: config.outputFile || Pajo.join(dirname, 'src\\auto-config.ts') || '',
+            modulesDir: config.modulesDir || Pajo.join(dirname, 'src\\modules') || '',
+            rootConfigPath: config.rootConfigPath || Pajo.join(dirname, 'src\\config.json') || '',
+            projectRoot: config.projectRoot || dirname || ''
+        };
+        console.log(`--> ConfigGenerator config:: `, this.config);
+    }
+    async generate() {
+        console.log('🔍 Scanning for configuration files...');
+        await this.discoverModules();
+        await this.generateAutoConfigFile();
+        console.log(`✅ Generated ${this.config.outputFile}`);
+        console.log(`📦 Found modules with config: ${Array.from(this.modules).join(', ')}`);
+    }
+    async discoverModules() {
+        try {
+            if (!fs.existsSync(this.config.modulesDir)) {
+                console.log(`⚠️ Modules directory not found: ${this.config.modulesDir}`);
+                return;
+            }
+            const moduleDirs = fs.readdirSync(this.config.modulesDir, { withFileTypes: true })
+                .filter(dirent => dirent.isDirectory())
+                .map(dirent => dirent.name);
+            for (const moduleName of moduleDirs) {
+                const configPath = path.join(this.config.modulesDir, moduleName, 'config.json');
+                if (fs.existsSync(configPath)) {
+                    this.modules.add(moduleName);
+                    console.log(`📁 Found config for module: ${moduleName}`);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error discovering modules:', error);
+        }
+    }
+    async generateAutoConfigFile() {
+        const outputDir = path.dirname(this.config.outputFile);
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        const content = this.generateFileContent();
+        fs.writeFileSync(this.config.outputFile, content, 'utf-8');
+    }
+    getRelativeImportPath(targetPath) {
+        const outputDir = path.dirname(this.config.outputFile);
+        const relative = path.relative(outputDir, targetPath);
+        let importPath = relative.replace(/\\/g, '/');
+        if (!importPath.startsWith('.') && !importPath.startsWith('/')) {
+            importPath = './' + importPath;
+        }
+        return importPath;
+    }
+    generateFileContent() {
+        const { rootConfigPath, modulesDir } = this.config;
+        const sortedModules = Array.from(this.modules).sort();
+        const rootConfigExists = fs.existsSync(rootConfigPath);
+        console.log(`📄 Root config exists: ${rootConfigExists} at ${rootConfigPath}`);
+        const baseImportPath = rootConfigExists
+            ? this.getRelativeImportPath(rootConfigPath)
+            : null;
+        const baseConfig = rootConfigExists && baseImportPath
+            ? `  'app': (() => import('${baseImportPath}').then(module => module.default || module))`
+            : `  'app': (() => Promise.resolve({}))`;
+        const modulesImports = sortedModules.map(moduleName => {
+            const configPath = path.join(modulesDir, moduleName, 'config.json');
+            const configExists = fs.existsSync(configPath);
+            if (configExists) {
+                const importPath = this.getRelativeImportPath(configPath);
+                console.log(`📄 Module ${moduleName} config: ${configPath} -> ${importPath}`);
+                return `  '${moduleName}': (() => import('${importPath}').then(module => module.default || module))`;
+            }
+            else {
+                console.log(`⚠️ Module ${moduleName} config not found: ${configPath}`);
+                return `  '${moduleName}': (() => Promise.resolve({}))`;
+            }
+        }).join(',\n');
+        return `export const configs = {
+  'base': {
+${baseConfig}
+  },
+  'modules': {
+${modulesImports.length > 0 ? modulesImports : '    // No modules with config.json found'}
+  }
+};
+
+export default configs;`;
+    }
+}
+async function ConfigInitiator(dirname = __dirname) {
+    const config = {};
+    const generator = new ConfigGenerator(config, dirname);
+    generator.generate().then(() => {
+        console.log('🎉 Config generation completed successfully!');
+    }).catch((err) => {
+        console.error('❌ Failed to generate config: ', err);
+    });
+}
+export default ConfigInitiator;

package/js/index.js

@@ -0,0 +1,10 @@
+import TranslationInitiator from './intl';
+import ConfigInitiator from './config';
+import RouteInitiator from './routing';
+import ProviderInitiator from './provider';
+export default function (dirname = __dirname) {
+    TranslationInitiator(dirname);
+    ConfigInitiator(dirname);
+    RouteInitiator(dirname);
+    ProviderInitiator(dirname);
+}