@jsarc/initiator 0.0.0 → 0.0.1-beta.0.1

package/README.md

@@ -5,7 +5,7 @@
 ![React](https://img.shields.io/badge/React-18+-61DAFB)
 ![React Router](https://img.shields.io/badge/React%20Router-6+-CA4245)
 
-**@jsarc/initiator** est un plugin d'initialisation intelligent pour les applications React avec TypeScript/Javascript. Il génère automatiquement les fichiers de configuration, de routage et d'internationalisation basés sur la structure de votre projet.
+**@jsarc/initiator** est un plugin d'initialisation intelligent pour les applications React avec TypeScript/Javascript. Il génère automatiquement les fichiers de configuration, de routage, d'internationalisation et de providers basés sur la structure de votre projet.
 
 ## ✨ Fonctionnalités Principales
 
@@ -13,19 +13,22 @@
 - **Génération automatique des routes** à partir de la structure du système de fichiers
 - **Configuration modulaire** avec détection automatique des modules
 - **Internationalisation automatisée** avec extraction des clés de traduction
+- **Providers React organisés** par module et priorité
 - **Fichiers de configuration** générés dynamiquement
 
 ### ⚙️ Initialisation Intelligente
-- **Détection automatique** des fichiers de pages et modules
+- **Détection automatique** des fichiers de pages, modules et providers
 - **Génération de fichiers TypeScript** typesafe
 - **Support des layouts hiérarchiques** avec héritage automatique
+- **Organisation automatique des providers** (Context, Redux, Router, etc.)
 - **Configuration minimale** requise
 
 ### 📁 Structure de Projet
 - **Organisation modulaire** naturelle
 - **Support des pages spéciales** (layout, error, 404)
 - **Routes dynamiques** avec paramètres
-- **Modules indépendants** avec leur propre configuration
+- **Modules indépendants** avec leur propre configuration et providers
+- **Providers globaux et par module** hiérarchisés
 
 ## 📦 Installation
 
@@ -78,10 +81,16 @@ src/
 ├── auto-config.ts      # Configuration générée
 ├── auto-intl.ts        # Internationalisation générée
 ├── auto-routes.tsx     # Routes générées
+├── auto-provider.tsx   # Providers organisés
 ├── config.json         # Configuration racine
 ├── locales/
 │   ├── en.json         # Traductions anglais
 │   └── fr.json         # Traductions français
+├── providers/          # Providers globaux
+│   ├── RouterProvider.tsx
+│   ├── ReduxProvider.tsx
+│   ├── ThemeProvider.tsx
+│   └── AuthProvider.tsx
 ├── pages/
 │   ├── _layout.tsx     # Layout racine
 │   ├── _error.tsx      # Page d'erreur
@@ -93,6 +102,9 @@ src/
         ├── locales/
         │   ├── en.json # Traductions module
         │   └── fr.json # Traductions module
+        ├── providers/  # Providers du module
+        │   ├── ReduxProvider.tsx
+        │   └── AuthProvider.tsx
         └── pages/
             └── index.tsx # Page du module
 ```
@@ -119,6 +131,14 @@ Génération centralisée de configuration :
 - **Configuration des modules** depuis `modules/*/config.json`
 - **Fichier TypeScript** avec imports dynamiques
 
+### 4. Génération de Providers
+Organisation automatique des providers React :
+- **Détection automatique** des fichiers provider (`Provider.tsx`)
+- **Hiérarchisation intelligente** par priorité
+- **Organisation par module** avec encapsulation automatique
+- **Chargement lazy** avec Suspense intégré
+- **Typage TypeScript** complet
+
 ## 📚 API du Plugin
 
 ### Fonction principale
@@ -137,13 +157,15 @@ init('/chemin/vers/mon/projet');
 import { 
   TranslationGenerator, 
   RouteGenerator, 
-  ConfigGenerator 
+  ConfigGenerator,
+  ProviderGenerator 
 } from '@jsarc/initiator';
 
 // Utilisation avancée
 const translationGen = new TranslationGenerator(config);
 const routeGen = new RouteGenerator(config);
 const configGen = new ConfigGenerator(config);
+const providerGen = new ProviderGenerator(config);
 ```
 
 ### Interfaces TypeScript
@@ -152,8 +174,10 @@ import type {
   TranslationConfig,
   RouteConfig,
   ConfigGeneratorOptions,
+  ProviderConfig,
   TranslationKey,
-  RouteFile
+  RouteFile,
+  ProviderInfo
 } from '@jsarc/initiator';
 ```
 
@@ -173,19 +197,17 @@ console.log('✅ Initialisation terminée !');
 ### Exemple 2 : Personnalisation avancée
 ```typescript
 // scripts/custom-init.ts
-import { RouteGenerator } from '@jsarc/initiator';
+import { ProviderGenerator } from '@jsarc/initiator';
 
 const customConfig = {
   srcDir: './src',
   modulesDir: './src/modules',
-  pagesDir: './src/views', // Dossier personnalisé
-  outputFile: './src/generated/routes.tsx',
-  layoutFileName: 'layout',
-  errorFileName: 'error-page',
-  notFoundFileName: 'not-found-page'
+  providersDir: './src/providers',
+  globalProvidersDir: './src/global-providers', // Dossier personnalisé
+  outputFile: './src/generated/provider.tsx'
 };
 
-const generator = new RouteGenerator(customConfig);
+const generator = new ProviderGenerator(customConfig);
 await generator.generate();
 ```
 
@@ -198,7 +220,8 @@ await generator.generate();
     "generate": "node scripts/generate-all.js",
     "generate:routes": "node scripts/generate-routes.js",
     "generate:intl": "node scripts/generate-intl.js",
-    "generate:config": "node scripts/generate-config.js"
+    "generate:config": "node scripts/generate-config.js",
+    "generate:providers": "node scripts/generate-providers.js"
   }
 }
 ```
@@ -229,6 +252,17 @@ const routeConfig = {
 };
 ```
 
+### Configuration des providers
+```typescript
+const providerConfig = {
+  srcDir: './src',
+  modulesDir: './src/modules',
+  providersDir: './src/providers',
+  outputFile: './src/auto-provider.tsx',
+  globalProvidersDir: './src/providers' // Dossier des providers globaux
+};
+```
+
 ### Fichier config.json racine
 ```json
 {
@@ -273,6 +307,16 @@ const routeConfig = {
 | `[...slug].tsx` | Route catch-all | `/*` |
 | `index.tsx` | Page d'index | `/` ou `/dossier/` |
 
+### Providers détectés automatiquement
+| Pattern | Type détecté | Priorité |
+|---------|-------------|----------|
+| `*Router*.tsx` | Provider Router | Haute |
+| `*Redux*.tsx` | Provider Redux | Haute |
+| `*Theme*.tsx` | Provider Theme | Moyenne |
+| `*Context*.tsx` | Provider Context | Moyenne |
+| `*Provider.tsx` | Provider générique | Basse |
+| `*Error*.tsx` | Error Boundary | Très basse |
+
 ### Structure de module
 ```
 modules/
@@ -281,6 +325,10 @@ modules/
     ├── locales/            # Traductions du module
     │   ├── en.json
     │   └── fr.json
+    ├── providers/          # Providers du module
+    │   ├── ReduxProvider.tsx
+    │   ├── AuthProvider.tsx
+    │   └── ThemeProvider.tsx
     ├── pages/              # Pages du module
     │   ├── _layout.tsx     # Layout du module
     │   ├── _error.tsx      # Erreur du module
@@ -307,18 +355,29 @@ npx @jsarc/initiator
 ### 2. Ajout d'un nouveau module
 ```bash
 # Créer la structure du module
-mkdir -p src/modules/admin/{locales,pages,components}
+mkdir -p src/modules/admin/{locales,providers,pages,components}
 
 # Ajouter les fichiers de base
 touch src/modules/admin/config.json
 touch src/modules/admin/pages/index.tsx
 touch src/modules/admin/locales/fr.json
+touch src/modules/admin/providers/ReduxProvider.tsx
 
 # Régénérer les fichiers
 npx @jsarc/initiator
 ```
 
-### 3. Développement avec hot-reload
+### 3. Ajout d'un provider global
+```bash
+# Créer un provider global
+mkdir -p src/providers
+touch src/providers/ThemeProvider.tsx
+
+# Régénérer le fichier auto-provider.tsx
+npx @jsarc/initiator
+```
+
+### 4. Développement avec hot-reload
 ```bash
 # Démarrer le serveur de développement
 npm run dev
@@ -345,6 +404,24 @@ export default defineConfig({
 });
 ```
 
+### Utilisation du AppProvider généré
+```tsx
+// main.tsx
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import App from './App';
+import { AppProvider } from './auto-provider';
+import './index.css';
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <AppProvider>
+      <App />
+    </AppProvider>
+  </React.StrictMode>
+);
+```
+
 ### Avec Next.js (Adaptation)
 ```javascript
 // next.config.js
@@ -403,6 +480,13 @@ module.exports = {
    npx @jsarc/initiator
    ```
 
+4. **Providers non détectés**
+   ```bash
+   # Vérifier que le fichier contient "Provider" dans le nom
+   # Ou utilise createContext / Context.Provider
+   mv src/my-context.tsx src/MyContextProvider.tsx
+   ```
+
 ### Logs de débogage
 ```bash
 # Activer les logs détaillés

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.0",
+  "version": "0.0.1-beta.0.1",
   "description": "INITIATOR est un plugin d'initialisation intelligent pour les applications React avec TypeScript/Javascript. Il génère automatiquement les fichiers de configuration, de routage et d'internationalisation basés sur la structure de votre projet.",
   "main": "index.ts",
   "keywords": [],

package/routing.ts

@@ -0,0 +1,621 @@
+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 RouteConfig {
+    srcDir: string;
+    modulesDir: string;
+    pagesDir: string;
+    outputFile: string;
+    layoutFileName: string;
+    errorFileName: string;
+    notFoundFileName: string;
+}
+
+export interface RouteFile {
+    filePath: string;
+    relativePath: string;
+    routePath: string;
+    componentName: string;
+    layoutComponent?: string;
+    errorComponent?: string;
+    notFoundComponent?: string;
+    moduleName?: string;
+}
+
+export class RouteGenerator {
+    private config: RouteConfig;
+    private routeFiles: RouteFile[] = [];
+    private modules: Set<string> = new Set();
+
+    constructor(
+        config: Partial<RouteConfig> = {},
+        dirname: string | undefined = __dirname,
+    ) {
+        this.config = {
+            srcDir: config.srcDir || Pajo.join(dirname, 'src') || '',
+            modulesDir: config.modulesDir || Pajo.join(dirname, 'src\\modules') || '',
+            pagesDir: config.pagesDir || Pajo.join(dirname, 'src\\pages') || '',
+            outputFile: config.outputFile || Pajo.join(dirname, 'src\\auto-routes.tsx') || '',
+            layoutFileName: config.layoutFileName || '_layout',
+            errorFileName: config.errorFileName || '_error',
+            notFoundFileName: config.notFoundFileName || '_404'
+        };
+        console.log(`--> RouteGenerator config:: `, this.config);
+    }
+
+    public async generate(): Promise<void> {
+        console.log('🔍 Scanning for route files...');
+
+        await this.findRouteFiles();
+
+        await this.generateAutoRoutesFile();
+
+        console.log(`✅ Generated ${this.config.outputFile} with ${this.routeFiles.length} routes`);
+        console.log(`📦 Found modules with routes: ${Array.from(this.modules).join(', ')}`);
+    }
+
+    private async findRouteFiles(): Promise<void> {
+        this.routeFiles = [];
+
+        await this.scanDirectoryForRoutes(this.config.pagesDir);
+
+        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 modulePagesDir = path.join(this.config.modulesDir, moduleName, 'pages');
+                if (fs.existsSync(modulePagesDir)) {
+                    this.modules.add(moduleName);
+                    await this.scanDirectoryForRoutes(modulePagesDir, moduleName);
+                }
+            }
+        }
+    }
+
+    private async scanDirectoryForRoutes(dir: string, moduleName?: string): Promise<void> {
+        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' ||
+                    item.name.startsWith('.')) {
+                    continue;
+                }
+
+                if (item.isDirectory()) {
+                    
+                    await this.scanDirectoryForRoutes(fullPath, moduleName);
+                } else if (item.isFile()) {
+                    
+                    const ext = path.extname(item.name).toLowerCase();
+                    if (['.tsx', '.jsx'].includes(ext)) {
+                        const fileName = path.basename(item.name, ext);
+
+                        if (fileName === this.config.layoutFileName ||
+                            fileName === this.config.errorFileName ||
+                            fileName === this.config.notFoundFileName) {
+                            continue;
+                        }
+
+                        await this.processRouteFile(fullPath, moduleName);
+                    }
+                }
+            }
+        } catch (error) {
+            console.error(`Error scanning directory ${dir}:`, error);
+        }
+    }
+
+    private async processRouteFile(filePath: string, moduleName?: string): Promise<void> {
+        try {
+            
+            let routePath = this.convertFilePathToRoutePath(filePath, moduleName);
+
+            const componentName = this.extractComponentName(filePath, moduleName);
+
+            const layoutComponent = this.findLayoutComponent(filePath, moduleName);
+            const errorComponent = this.findErrorComponent(filePath, moduleName);
+            const notFoundComponent = this.findNotFoundComponent(filePath, moduleName);
+
+            const routeFile: RouteFile = {
+                filePath,
+                relativePath: path.relative(this.config.srcDir, filePath),
+                routePath,
+                componentName,
+                layoutComponent,
+                errorComponent,
+                notFoundComponent,
+                moduleName
+            };
+
+            this.routeFiles.push(routeFile);
+        } catch (error) {
+            console.error(`Error processing route file ${filePath}:`, error);
+        }
+    }
+
+    private convertFilePathToRoutePath(filePath: string, moduleName?: string): string {
+        let routePath = filePath;
+
+        routePath = routePath.replace(this.config.srcDir, '');
+
+        if (moduleName) {
+            
+            const modulePagesPrefix = `modules${path.sep}${moduleName}${path.sep}pages`;
+            if (routePath.includes(modulePagesPrefix)) {
+                routePath = routePath.substring(routePath.indexOf(modulePagesPrefix) + modulePagesPrefix.length);
+                
+                routePath = `/${moduleName}${routePath}`;
+            }
+        } else {
+            
+            const pagesPrefix = 'pages';
+            if (routePath.includes(pagesPrefix)) {
+                routePath = routePath.substring(routePath.indexOf(pagesPrefix) + pagesPrefix.length);
+            }
+        }
+
+        routePath = routePath.replace(/\.(tsx|jsx)$/, '');
+
+        routePath = routePath.replace(/\\/g, '/');
+
+        if (routePath.endsWith('/index')) {
+            routePath = routePath.replace(/\/index$/, '');
+        }
+
+        routePath = routePath.replace(/\[([^\]]+)\]/g, '{$1}');
+
+        if (!routePath.startsWith('/')) {
+            routePath = '/' + routePath;
+        }
+
+        if (routePath === '/' || routePath === '//') {
+            return '/';
+        }
+
+        return routePath;
+    }
+
+    private extractComponentName(filePath: string, moduleName?: string): string {
+        const fileName = path.basename(filePath, path.extname(filePath));
+        const dirName = path.dirname(filePath);
+
+        const parts = dirName.split(path.sep);
+
+        let startIndex = 0;
+        if (moduleName) {
+            
+            const modulePagesPath = path.sep + 'modules' + path.sep + moduleName + path.sep + 'pages';
+            startIndex = parts.findIndex((part, index, arr) => {
+                const pathSoFar = arr.slice(0, index + 1).join(path.sep);
+                return pathSoFar.endsWith(modulePagesPath);
+            }) + 1;
+        } else {
+            
+            const pagesPath = path.sep + 'pages';
+            startIndex = parts.findIndex((part, index, arr) => {
+                const pathSoFar = arr.slice(0, index + 1).join(path.sep);
+                return pathSoFar.endsWith(pagesPath);
+            }) + 1;
+        }
+        
+        if (startIndex < 0) startIndex = 0;
+
+        const relevantParts = parts.slice(startIndex);
+
+        let componentName = moduleName ? this.toPascalCase(moduleName) : '';
+
+        relevantParts.forEach(part => {
+            if (part && part !== 'pages') {
+                componentName += this.toPascalCase(part);
+            }
+        });
+
+        let fileNamePart = fileName;
+        if (fileName.startsWith('{') && fileName.endsWith('}')) {
+            
+            const paramName = fileName.substring(1, fileName.length - 1);
+            fileNamePart = this.toPascalCase(paramName) + 'Params';
+        } else {
+            fileNamePart = this.toPascalCase(fileName);
+        }
+
+        if (!fileNamePart.endsWith('Page')) {
+            fileNamePart += 'Page';
+        }
+
+        const reservedNames = ['Layout', 'ErrorBoundary', 'NotFound'];
+        if (reservedNames.includes(fileNamePart)) {
+            fileNamePart += 'Component';
+        }
+        
+        return componentName + fileNamePart;
+    }
+
+    private toPascalCase(str: string): string {
+        if (!str) return '';
+        return str
+            .split(/[-_]/)
+            .map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+            .join('');
+    }
+
+    private findLayoutComponent(filePath: string, moduleName?: string): string | undefined {
+        const dir = path.dirname(filePath);
+        let currentDir = dir;
+
+        while (currentDir !== this.config.srcDir && currentDir !== path.dirname(this.config.srcDir)) {
+            const layoutPath = path.join(currentDir, `${this.config.layoutFileName}.tsx`);
+            
+            if (fs.existsSync(layoutPath)) {
+                return this.generateComponentName(layoutPath, moduleName, 'Layout');
+            }
+
+            if (moduleName) {
+                const modulePath = path.join(this.config.modulesDir, moduleName);
+                if (currentDir === modulePath) {
+                    break;
+                }
+            }
+            
+            currentDir = path.dirname(currentDir);
+        }
+
+        const globalLayoutPath = path.join(this.config.pagesDir, `${this.config.layoutFileName}.tsx`);
+        if (fs.existsSync(globalLayoutPath)) {
+            return 'Layout';
+        }
+        
+        return undefined;
+    }
+
+    private findErrorComponent(filePath: string, moduleName?: string): string | undefined {
+        const dir = path.dirname(filePath);
+        let currentDir = dir;
+
+        while (currentDir !== this.config.srcDir && currentDir !== path.dirname(this.config.srcDir)) {
+            const errorPath = path.join(currentDir, `${this.config.errorFileName}.tsx`);
+            
+            if (fs.existsSync(errorPath)) {
+                return this.generateComponentName(errorPath, moduleName, 'ErrorBoundary');
+            }
+
+            if (moduleName) {
+                const modulePath = path.join(this.config.modulesDir, moduleName);
+                if (currentDir === modulePath) {
+                    break;
+                }
+            }
+            
+            currentDir = path.dirname(currentDir);
+        }
+
+        const globalErrorPath = path.join(this.config.pagesDir, `${this.config.errorFileName}.tsx`);
+        if (fs.existsSync(globalErrorPath)) {
+            return 'ErrorBoundary';
+        }
+        
+        return undefined;
+    }
+
+    private findNotFoundComponent(filePath: string, moduleName?: string): string | undefined {
+        if (!moduleName) return undefined;
+        
+        const modulePagesDir = path.join(this.config.modulesDir, moduleName, 'pages');
+        const notFoundPath = path.join(modulePagesDir, `${this.config.notFoundFileName}.tsx`);
+        
+        if (fs.existsSync(notFoundPath)) {
+            return this.generateComponentName(notFoundPath, moduleName, 'NotFound');
+        }
+        
+        return undefined;
+    }
+
+    private generateComponentName(filePath: string, moduleName: string | undefined, suffix: string): string {
+        if (!moduleName) {
+            return suffix;
+        }
+        
+        const fileName = path.basename(filePath, path.extname(filePath));
+        const dirName = path.dirname(filePath);
+
+        const modulePagesPath = path.join(this.config.modulesDir, moduleName, 'pages');
+        const relativePath = path.relative(modulePagesPath, dirName);
+        
+        let componentName = this.toPascalCase(moduleName);
+
+        if (relativePath && relativePath !== '.') {
+            const dirParts = relativePath.split(path.sep).filter(part => part && part !== '.');
+            dirParts.forEach(part => {
+                componentName += this.toPascalCase(part);
+            });
+        }
+
+        if (fileName !== this.config.layoutFileName && 
+            fileName !== this.config.errorFileName && 
+            fileName !== this.config.notFoundFileName) {
+            componentName += this.toPascalCase(fileName);
+        }
+        
+        return componentName + suffix;
+    }
+
+    private async generateAutoRoutesFile(): 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)$/, '');
+        
+        return importPath;
+    }
+
+    private generateFileContent(): string {
+        
+        const components = new Set<string>();
+        const imports: string[] = [
+            `import { lazy } from 'react';`,
+            `import type { RouteObject } from 'react-router-dom';`,
+            ``
+        ];
+
+        const globalLayoutPath = path.join(this.config.pagesDir, `${this.config.layoutFileName}.tsx`);
+        const globalErrorPath = path.join(this.config.pagesDir, `${this.config.errorFileName}.tsx`);
+        const global404Path = path.join(this.config.pagesDir, `${this.config.notFoundFileName}.tsx`);
+
+        if (fs.existsSync(globalLayoutPath)) {
+            const importPath = this.getRelativeImportPath(globalLayoutPath);
+            imports.push(`const Layout = lazy(() => import('${importPath}'));`);
+            components.add('Layout');
+        }
+
+        if (fs.existsSync(globalErrorPath)) {
+            const importPath = this.getRelativeImportPath(globalErrorPath);
+            imports.push(`const ErrorBoundary = lazy(() => import('${importPath}'));`);
+            components.add('ErrorBoundary');
+        }
+
+        if (fs.existsSync(global404Path)) {
+            const importPath = this.getRelativeImportPath(global404Path);
+            imports.push(`const NotFound = lazy(() => import('${importPath}'));`);
+            components.add('NotFound');
+        }
+
+        imports.push(``);
+
+        const specialComponents = new Map<string, string>(); 
+
+        const findSpecialFiles = (baseDir: string, isModule: boolean = false, moduleName?: string) => {
+            if (!fs.existsSync(baseDir)) return;
+            
+            const walkDir = (dir: string) => {
+                try {
+                    const items = fs.readdirSync(dir, { withFileTypes: true });
+                    
+                    for (const item of items) {
+                        const fullPath = path.join(dir, item.name);
+                        
+                        if (item.isDirectory()) {
+                            walkDir(fullPath);
+                        } else if (item.isFile()) {
+                            const ext = path.extname(item.name).toLowerCase();
+                            if (['.tsx', '.jsx'].includes(ext)) {
+                                const fileName = path.basename(item.name, ext);
+                                
+                                if (fileName === this.config.layoutFileName ||
+                                    fileName === this.config.errorFileName ||
+                                    fileName === this.config.notFoundFileName) {
+                                    
+                                    const componentName = this.generateComponentName(fullPath, moduleName, 
+                                        fileName === this.config.layoutFileName ? 'Layout' :
+                                        fileName === this.config.errorFileName ? 'ErrorBoundary' : 'NotFound');
+                                    
+                                    if (!components.has(componentName)) {
+                                        specialComponents.set(fullPath, componentName);
+                                        components.add(componentName);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                } catch (error) {
+                    console.error(`Error walking directory ${dir}:`, error);
+                }
+            };
+            
+            walkDir(baseDir);
+        };
+
+        findSpecialFiles(this.config.pagesDir, false);
+
+        this.modules.forEach(moduleName => {
+            const modulePagesDir = path.join(this.config.modulesDir, moduleName, 'pages');
+            if (fs.existsSync(modulePagesDir)) {
+                findSpecialFiles(modulePagesDir, true, moduleName);
+            }
+        });
+
+        specialComponents.forEach((componentName, filePath) => {
+            const importPath = this.getRelativeImportPath(filePath);
+            imports.push(`const ${componentName} = lazy(() => import('${importPath}'));`);
+        });
+
+        if (specialComponents.size > 0) {
+            imports.push(``);
+        }
+
+        this.routeFiles.forEach(route => {
+            
+            const importPath = this.getRelativeImportPath(route.filePath);
+            imports.push(`const ${route.componentName} = lazy(() => import('${importPath}'));`);
+            components.add(route.componentName);
+        });
+
+        imports.push(``);
+
+        const routes: string[] = ['export const routes: RouteObject[] = ['];
+
+        const sortedRoutes = this.routeFiles.sort((a, b) => {
+            
+            if (a.routePath === '/') return -1;
+            if (b.routePath === '/') return 1;
+
+            if (!a.moduleName && b.moduleName) return -1;
+            if (a.moduleName && !b.moduleName) return 1;
+
+            if (a.moduleName === b.moduleName) {
+                return a.routePath.localeCompare(b.routePath);
+            }
+            
+            return 0;
+        });
+        
+        let lastModuleName: string | undefined = undefined;
+        
+        sortedRoutes.forEach((route, index) => {
+            
+            if (route.moduleName !== lastModuleName) {
+                if (lastModuleName !== undefined) {
+                    routes.push(``);
+                }
+                if (route.moduleName) {
+                    routes.push(`  // ${route.moduleName} module routes`);
+                }
+                lastModuleName = route.moduleName;
+            }
+            
+            const routeLines: string[] = ['  {'];
+            routeLines.push(`    path: '${route.routePath.replace(/\{([^}]+)\}/g, ':$1')}',`);
+
+            let layoutComponent = route.layoutComponent;
+            if (!layoutComponent && route.moduleName) {
+                
+                const moduleLayoutPath = path.join(this.config.modulesDir, route.moduleName, 'pages', `${this.config.layoutFileName}.tsx`);
+                if (fs.existsSync(moduleLayoutPath)) {
+                    layoutComponent = this.generateComponentName(moduleLayoutPath, route.moduleName, 'Layout');
+                }
+            }
+
+            if (layoutComponent) {
+                routeLines.push(`    element: <${layoutComponent}><${route.componentName} /></${layoutComponent}>,`);
+            } else {
+                routeLines.push(`    element: <${route.componentName} />,`);
+            }
+
+            let errorComponent = route.errorComponent;
+            if (!errorComponent && route.moduleName) {
+                
+                const moduleErrorPath = path.join(this.config.modulesDir, route.moduleName, 'pages', `${this.config.errorFileName}.tsx`);
+                if (fs.existsSync(moduleErrorPath)) {
+                    errorComponent = this.generateComponentName(moduleErrorPath, route.moduleName, 'ErrorBoundary');
+                }
+            }
+            
+            if (errorComponent) {
+                routeLines.push(`    errorElement: <${errorComponent} />`);
+            }
+
+            if (routeLines[routeLines.length - 1].endsWith(',')) {
+                routeLines[routeLines.length - 1] = routeLines[routeLines.length - 1].slice(0, -1);
+            }
+            
+            routeLines.push('  }');
+            
+            if (index < sortedRoutes.length - 1) {
+                routeLines[routeLines.length - 1] += ',';
+            }
+            
+            routes.push(routeLines.join('\n'));
+        });
+
+        const modulesWith404 = new Set<string>();
+        specialComponents.forEach((componentName, filePath) => {
+            const fileName = path.basename(filePath, path.extname(filePath));
+            if (fileName === this.config.notFoundFileName) {
+                
+                const pathParts = filePath.split(path.sep);
+                const modulesIndex = pathParts.indexOf('modules');
+                if (modulesIndex !== -1 && modulesIndex + 1 < pathParts.length) {
+                    const moduleName = pathParts[modulesIndex + 1];
+                    if (!modulesWith404.has(moduleName)) {
+                        modulesWith404.add(moduleName);
+                        
+                        if (routes[routes.length - 1].endsWith(',')) {
+                            routes[routes.length - 1] = routes[routes.length - 1].slice(0, -1);
+                        }
+                        routes.push(`,`);
+                        routes.push(`  {`);
+                        routes.push(`    path: '/${moduleName}/*',`.replace(/\{([^}]+)\}/g, ':$1'));
+                        routes.push(`    element: <${componentName} />`);
+                        routes.push(`  }`);
+                    }
+                }
+            }
+        });
+
+        if (components.has('NotFound')) {
+            if (routes[routes.length - 1].endsWith(',')) {
+                routes[routes.length - 1] = routes[routes.length - 1].slice(0, -1);
+            }
+            routes.push(`,`);
+            routes.push(`  {`);
+            routes.push(`    path: '*',`.replace(/\{([^}]+)\}/g, ':$1'));
+            routes.push(`    element: <NotFound />`);
+            routes.push(`  }`);
+        }
+
+        routes.push('];');
+        routes.push('');
+        routes.push('export default routes;');
+
+        return [
+            ...imports,
+            '',
+            ...routes
+        ].join('\n');
+    }
+}
+
+async function RouteInitiator(
+    dirname: string | undefined = __dirname
+) {
+    const config: Partial<RouteConfig> = {};
+
+    const generator = new RouteGenerator(config, dirname);
+
+    try {
+        await generator.generate();
+        console.log('🎉 Route generation completed successfully!');
+    } catch (err) {
+        console.error('❌ Failed to generate routes: ', err);
+    }
+}
+
+export default RouteInitiator;