@jsarc/initiator 0.0.0

package/provider.ts

@@ -0,0 +1,423 @@
+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 interface ProviderConfig {
+    srcDir: string;
+    modulesDir: string;
+    providersDir: string;
+    outputFile: string;
+    globalProvidersDir: string;
+}
+
+export interface ProviderInfo {
+    filePath: string;
+    componentName: string;
+    moduleName?: string;
+    priority: number;
+    isGlobal: boolean;
+    providerType: 'context' | 'redux' | 'router' | 'theme' | 'other';
+}
+
+export class ProviderGenerator {
+    private config: ProviderConfig;
+    private providers: ProviderInfo[] = [];
+    private modules: Set<string> = new Set();
+
+    constructor(
+        config: Partial<ProviderConfig> = {},
+        dirname: string | undefined = __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);
+    }
+
+    public async generate(): Promise<void> {
+        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(', ')}`);
+    }
+
+    private async findProviderFiles(): Promise<void> {
+        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);
+                }
+            }
+        }
+    }
+
+    private async scanDirectoryForProviders(dir: string, moduleName?: string, isGlobal: boolean = false): Promise<void> {
+        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);
+        }
+    }
+
+    private async processProviderFile(filePath: string, moduleName?: string, isGlobal: boolean = false): Promise<void> {
+        try {
+            
+            const componentName = this.extractComponentName(filePath, moduleName, isGlobal);
+
+            const providerType = this.determineProviderType(filePath, componentName);
+            const priority = this.determineProviderPriority(providerType, componentName, isGlobal);
+            
+            const providerInfo: 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);
+        }
+    }
+
+    private extractComponentName(filePath: string, moduleName?: string, isGlobal?: boolean): string {
+        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;
+    }
+
+    private toPascalCase(str: string): string {
+        if (!str) return '';
+        return str
+            .split(/[-_]/)
+            .map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+            .join('');
+    }
+
+    private isLikelyProviderFile(filePath: string): boolean {
+        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;
+        }
+    }
+
+    private determineProviderType(filePath: string, componentName: string): ProviderInfo['providerType'] {
+        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';
+        }
+    }
+
+    private determineProviderPriority(type: ProviderInfo['providerType'], componentName: string, isGlobal: boolean): number {
+
+        const basePriority = isGlobal ? 100 : 200;
+        
+        const typePriority: Record<ProviderInfo['providerType'], number> = {
+            '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);
+    }
+
+    private async generateAutoProviderFile(): Promise<void> {
+        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');
+    }
+
+    private getRelativeImportPath(targetPath: string): string {
+        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;
+    }
+
+    private generateFileContent(): string {
+        
+        const sortedProviders = [...this.providers].sort((a, b) => a.priority - b.priority);
+
+        const providersByModule: Record<string, ProviderInfo[]> = {};
+        const globalProviders: ProviderInfo[] = [];
+        
+        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: string[] = [
+            `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: string[] = [];
+
+        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');
+    }
+    
+    private tryGetExportName(filePath: string, defaultName: string): string {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+
+            const exportRegex = /export\s+(?:const|let|var|function|class)\s+(\w+)/g;
+            const exports: string[] = [];
+            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: string | undefined = __dirname
+) {
+    const config: Partial<ProviderConfig> = {};
+
+    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;

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+    "compilerOptions": {
+        "target": "ES6",
+        "module": "commonjs",
+        "lib": ["ES2020", "DOM", "DOM.Iterable", "ESNext"],
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "declaration": false,
+        "sourceMap": false,
+        "allowSyntheticDefaultImports": true,
+        "noEmit": false,
+        
+        "strict": false,
+        "noImplicitAny": false,
+        "strictNullChecks": false,
+        "strictFunctionTypes": false,
+        "strictBindCallApply": false,
+        "strictPropertyInitialization": false,
+        "noImplicitThis": false,
+        "alwaysStrict": false
+    },
+    "include": [],
+    "exclude": [
+        "node_modules",
+        "**/*.d.ts"
+    ]
+}