@jsarc/initiator 0.0.0

package/js/intl.js

@@ -0,0 +1,274 @@
+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 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 || ['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);
+    }
+    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;

package/js/provider.js

@@ -0,0 +1,323 @@
+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 ProviderGenerator {
+    config;
+    providers = [];
+    modules = new Set();
+    constructor(config = {}, dirname = __dirname) {
+        this.config = {
+            srcDir: config.srcDir || Pajo.join(dirname, 'src') || '',
+            modulesDir: config.modulesDir || Pajo.join(dirname, 'src\\modules') || '',
+            providersDir: config.providersDir || Pajo.join(dirname, 'src\\providers') || '',
+            outputFile: config.outputFile || Pajo.join(dirname, 'src\\auto-provider.tsx') || '',
+            globalProvidersDir: config.globalProvidersDir || Pajo.join(dirname, 'src\\providers') || ''
+        };
+        console.log(`--> ProviderGenerator config:: `, this.config);
+    }
+    async generate() {
+        console.log('🔍 Scanning for provider files...');
+        await this.findProviderFiles();
+        await this.generateAutoProviderFile();
+        console.log(`✅ Generated ${this.config.outputFile} with ${this.providers.length} providers`);
+        console.log(`📦 Found modules with providers: ${Array.from(this.modules).join(', ')}`);
+    }
+    async findProviderFiles() {
+        this.providers = [];
+        await this.scanDirectoryForProviders(this.config.globalProvidersDir, undefined, true);
+        if (fs.existsSync(this.config.modulesDir)) {
+            const moduleDirs = fs.readdirSync(this.config.modulesDir, { withFileTypes: true })
+                .filter(dirent => dirent.isDirectory())
+                .map(dirent => dirent.name);
+            for (const moduleName of moduleDirs) {
+                const moduleProvidersDir = path.join(this.config.modulesDir, moduleName, 'providers');
+                if (fs.existsSync(moduleProvidersDir)) {
+                    this.modules.add(moduleName);
+                    await this.scanDirectoryForProviders(moduleProvidersDir, moduleName, false);
+                }
+            }
+        }
+    }
+    async scanDirectoryForProviders(dir, moduleName, isGlobal = false) {
+        try {
+            if (!fs.existsSync(dir)) {
+                return;
+            }
+            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' ||
+                    item.name.startsWith('.') ||
+                    item.name === 'index.ts' ||
+                    item.name === 'index.tsx' ||
+                    item.name === 'auto-provider.tsx') {
+                    continue;
+                }
+                if (item.isDirectory()) {
+                    await this.scanDirectoryForProviders(fullPath, moduleName, isGlobal);
+                }
+                else if (item.isFile()) {
+                    const ext = path.extname(item.name).toLowerCase();
+                    if (['.tsx', '.jsx', '.ts', '.js'].includes(ext)) {
+                        const fileName = path.basename(item.name, ext);
+                        if (fileName.includes('Provider') || this.isLikelyProviderFile(fullPath)) {
+                            await this.processProviderFile(fullPath, moduleName, isGlobal);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error scanning directory ${dir}:`, error);
+        }
+    }
+    async processProviderFile(filePath, moduleName, isGlobal = false) {
+        try {
+            const componentName = this.extractComponentName(filePath, moduleName, isGlobal);
+            const providerType = this.determineProviderType(filePath, componentName);
+            const priority = this.determineProviderPriority(providerType, componentName, isGlobal);
+            const providerInfo = {
+                filePath,
+                componentName,
+                moduleName,
+                priority,
+                isGlobal,
+                providerType
+            };
+            this.providers.push(providerInfo);
+            console.log(`📦 Found provider: ${componentName} (${providerType}, priority: ${priority})`);
+        }
+        catch (error) {
+            console.error(`Error processing provider file ${filePath}:`, error);
+        }
+    }
+    extractComponentName(filePath, moduleName, isGlobal) {
+        const fileName = path.basename(filePath, path.extname(filePath));
+        let componentName = fileName
+            .replace(/\.provider$/i, '')
+            .replace(/Provider$/i, '')
+            .replace(/\.context$/i, '');
+        if (!componentName.match(/^[A-Z]/)) {
+            componentName = this.toPascalCase(componentName);
+        }
+        if (!componentName.endsWith('Provider')) {
+            componentName += 'Provider';
+        }
+        if (moduleName && isGlobal === false) {
+            const modulePrefix = this.toPascalCase(moduleName);
+            if (!componentName.startsWith(modulePrefix)) {
+                componentName = modulePrefix + componentName;
+            }
+        }
+        return componentName;
+    }
+    toPascalCase(str) {
+        if (!str)
+            return '';
+        return str
+            .split(/[-_]/)
+            .map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+            .join('');
+    }
+    isLikelyProviderFile(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const providerPatterns = [
+                /createContext/i,
+                /Context\.Provider/i,
+                /Provider.*children/i,
+                /<Provider/i,
+                /export.*Provider/i
+            ];
+            return providerPatterns.some(pattern => pattern.test(content));
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    determineProviderType(filePath, componentName) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8').toLowerCase();
+            const fileName = path.basename(filePath).toLowerCase();
+            if (content.includes('redux') || content.includes('store') || fileName.includes('redux') || fileName.includes('store')) {
+                return 'redux';
+            }
+            if (content.includes('react-router') || content.includes('browserrouter') || fileName.includes('router')) {
+                return 'router';
+            }
+            if (content.includes('theme') || content.includes('themeprovider') || fileName.includes('theme')) {
+                return 'theme';
+            }
+            if (content.includes('createcontext') || content.includes('context.provider') || fileName.includes('context')) {
+                return 'context';
+            }
+            return 'other';
+        }
+        catch (error) {
+            return 'other';
+        }
+    }
+    determineProviderPriority(type, componentName, isGlobal) {
+        const basePriority = isGlobal ? 100 : 200;
+        const typePriority = {
+            'router': 10,
+            'redux': 20,
+            'context': 30,
+            'theme': 40,
+            'other': 50
+        };
+        if (componentName.includes('Router') || componentName.includes('BrowserRouter')) {
+            return basePriority + 5;
+        }
+        if (componentName.includes('Error') || componentName.includes('Boundary')) {
+            return basePriority + 100;
+        }
+        if (componentName.includes('Toast') || componentName.includes('Notification')) {
+            return basePriority + 90;
+        }
+        return basePriority + (typePriority[type] || 50);
+    }
+    async generateAutoProviderFile() {
+        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;
+        }
+        importPath = importPath.replace(/\.(tsx|jsx|ts|js)$/, '');
+        return importPath;
+    }
+    generateFileContent() {
+        const sortedProviders = [...this.providers].sort((a, b) => a.priority - b.priority);
+        const providersByModule = {};
+        const globalProviders = [];
+        sortedProviders.forEach(provider => {
+            if (provider.isGlobal || !provider.moduleName) {
+                globalProviders.push(provider);
+            }
+            else {
+                if (!providersByModule[provider.moduleName]) {
+                    providersByModule[provider.moduleName] = [];
+                }
+                providersByModule[provider.moduleName].push(provider);
+            }
+        });
+        const imports = [
+            `import React, { ReactNode, lazy } from 'react';`,
+            `import { Suspense } from 'react';`,
+            ``,
+            `// Loading fallback component`,
+            `const LoadingFallback = ({ children }: { children: ReactNode }) => (`,
+            `  <div style={{`,
+            `    display: 'flex',`,
+            `    justifyContent: 'center',`,
+            `    alignItems: 'center',`,
+            `    minHeight: '100vh'`,
+            `  }}>`,
+            `    <div>Loading...</div>`,
+            `  </div>`,
+            `);`,
+            ``
+        ];
+        const allProviders = [...globalProviders, ...Object.values(providersByModule).flat()];
+        allProviders.forEach(provider => {
+            const importPath = this.getRelativeImportPath(provider.filePath);
+            const actualExportName = this.tryGetExportName(provider.filePath, provider.componentName);
+            imports.push(`const ${provider.componentName} = lazy(() => import('${importPath}').then(module => ({ default: module.${actualExportName} || module.default || module })));`);
+        });
+        imports.push(``);
+        const moduleComponents = [];
+        Object.entries(providersByModule).forEach(([moduleName, moduleProviders]) => {
+            const pascalModuleName = this.toPascalCase(moduleName);
+            const componentName = `${pascalModuleName}Providers`;
+            const sortedModuleProviders = moduleProviders.sort((a, b) => a.priority - b.priority);
+            let nestedJSX = '{children}';
+            sortedModuleProviders.forEach(provider => {
+                nestedJSX = `<${provider.componentName}>\n      ${nestedJSX}\n    </${provider.componentName}>`;
+            });
+            moduleComponents.push(`const ${componentName} = ({ children }: { children: ReactNode }) => (
+  ${nestedJSX}
+);`);
+            moduleComponents.push(``);
+        });
+        const sortedGlobalProviders = globalProviders.sort((a, b) => a.priority - b.priority);
+        let globalNestedJSX = '{children}';
+        sortedGlobalProviders.forEach(provider => {
+            globalNestedJSX = `<${provider.componentName}>\n    ${globalNestedJSX}\n  </${provider.componentName}>`;
+        });
+        moduleComponents.push(`const GlobalProviders = ({ children }: { children: ReactNode }) => (
+  ${globalNestedJSX}
+);`);
+        moduleComponents.push(``);
+        const allModuleNames = Object.keys(providersByModule);
+        let mainNestedJSX = '{children}';
+        allModuleNames.sort().forEach(moduleName => {
+            const pascalModuleName = this.toPascalCase(moduleName);
+            const componentName = `${pascalModuleName}Providers`;
+            mainNestedJSX = `<${componentName}>\n    ${mainNestedJSX}\n  </${componentName}>`;
+        });
+        mainNestedJSX = `<GlobalProviders>\n  ${mainNestedJSX}\n</GlobalProviders>`;
+        moduleComponents.push(`export const AppProvider = ({ children }: { children: ReactNode }) => (
+  <Suspense fallback={<LoadingFallback>{children}</LoadingFallback>}>
+    ${mainNestedJSX}
+  </Suspense>
+);`);
+        moduleComponents.push(``);
+        moduleComponents.push(`export default AppProvider;`);
+        return [
+            ...imports,
+            ...moduleComponents
+        ].join('\n');
+    }
+    tryGetExportName(filePath, defaultName) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const exportRegex = /export\s+(?:const|let|var|function|class)\s+(\w+)/g;
+            const exports = [];
+            let match;
+            while ((match = exportRegex.exec(content)) !== null) {
+                exports.push(match[1]);
+            }
+            const defaultExportRegex = /export\s+default\s+(\w+)/;
+            const defaultMatch = defaultExportRegex.exec(content);
+            if (exports.includes(defaultName)) {
+                return defaultName;
+            }
+            else if (defaultMatch) {
+                return defaultMatch[1];
+            }
+            else if (exports.length > 0) {
+                return exports[0];
+            }
+            return 'default';
+        }
+        catch (error) {
+            return 'default';
+        }
+    }
+}
+async function ProviderInitiator(dirname = __dirname) {
+    const config = {};
+    const generator = new ProviderGenerator(config, dirname);
+    try {
+        await generator.generate();
+        console.log('🎉 Provider generation completed successfully!');
+    }
+    catch (err) {
+        console.error('❌ Failed to generate providers: ', err);
+    }
+}
+export default ProviderInitiator;