@arcpkg/initiator 0.0.1-beta.0.1

package/js/provider.js

@@ -0,0 +1,303 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { Pajo } from '@arcpkg/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, { lazy } from 'react';`,
+            ``,
+            ``
+        ];
+        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: any }) => (<>${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: any }) => (<>${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: any }) => (<>${mainNestedJSX}</>);`);
+        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;