@jsarc/initiator 0.0.0

package/README.md

@@ -0,0 +1,440 @@
+# @jsarc/initiator
+
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-007ACC)
+![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.
+
+## ✨ Fonctionnalités Principales
+
+### 🗺️ Génération Automatique
+- **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
+- **Fichiers de configuration** générés dynamiquement
+
+### ⚙️ Initialisation Intelligente
+- **Détection automatique** des fichiers de pages et modules
+- **Génération de fichiers TypeScript** typesafe
+- **Support des layouts hiérarchiques** avec héritage automatique
+- **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
+
+## 📦 Installation
+
+### Installation globale (recommandée)
+```bash
+npm install -g @jsarc/initiator
+# ou
+yarn global add @jsarc/initiator
+# ou
+pnpm add -g @jsarc/initiator
+```
+
+### Installation locale
+```bash
+npm install @jsarc/initiator
+# ou
+yarn add @jsarc/initiator
+# ou
+pnpm add @jsarc/initiator
+```
+
+## 🚀 Utilisation Rapide
+
+### Commande de base
+```bash
+# Depuis la racine de votre projet
+arc-init
+# ou
+npx @jsarc/initiator
+```
+
+### Options disponibles
+```bash
+# Initialiser avec un répertoire spécifique
+arc-init --dir ./mon-projet
+
+# Forcer la régénération des fichiers
+arc-init --force
+
+# Mode silencieux (moins de logs)
+arc-init --quiet
+
+# Afficher l'aide
+arc-init --help
+```
+
+### Structure de projet générée
+```
+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
+├── config.json         # Configuration racine
+├── locales/
+│   ├── en.json         # Traductions anglais
+│   └── fr.json         # Traductions français
+├── pages/
+│   ├── _layout.tsx     # Layout racine
+│   ├── _error.tsx      # Page d'erreur
+│   ├── _404.tsx        # Page 404
+│   └── index.tsx       # Page d'accueil
+└── modules/
+    └── example/
+        ├── config.json # Configuration du module
+        ├── locales/
+        │   ├── en.json # Traductions module
+        │   └── fr.json # Traductions module
+        └── pages/
+            └── index.tsx # Page du module
+```
+
+## 🔧 Fonctionnalités Détaillées
+
+### 1. Génération de Routes
+Le plugin scanne automatiquement vos dossiers `pages/` et `modules/*/pages/` pour :
+- **Créer des routes React Router** automatiquement
+- **Gérer les layouts hiérarchiques**
+- **Supporter les pages d'erreur spécifiques**
+- **Générer des composants lazy-loaded**
+
+### 2. Internationalisation
+Extraction automatique des clés de traduction :
+- **Scan des fichiers source** pour les appels `t()`
+- **Détection des modules** avec fichiers de traduction
+- **Génération des imports dynamiques**
+- **Support multi-langue**
+
+### 3. Configuration
+Génération centralisée de configuration :
+- **Configuration racine** depuis `config.json`
+- **Configuration des modules** depuis `modules/*/config.json`
+- **Fichier TypeScript** avec imports dynamiques
+
+## 📚 API du Plugin
+
+### Fonction principale
+```typescript
+import init from '@jsarc/initiator';
+
+// Initialisation par défaut (utilise __dirname)
+init();
+
+// Avec répertoire personnalisé
+init('/chemin/vers/mon/projet');
+```
+
+### Classes exportées
+```typescript
+import { 
+  TranslationGenerator, 
+  RouteGenerator, 
+  ConfigGenerator 
+} from '@jsarc/initiator';
+
+// Utilisation avancée
+const translationGen = new TranslationGenerator(config);
+const routeGen = new RouteGenerator(config);
+const configGen = new ConfigGenerator(config);
+```
+
+### Interfaces TypeScript
+```typescript
+import type {
+  TranslationConfig,
+  RouteConfig,
+  ConfigGeneratorOptions,
+  TranslationKey,
+  RouteFile
+} from '@jsarc/initiator';
+```
+
+## 🎯 Exemples d'Utilisation
+
+### Exemple 1 : Script d'initialisation
+```javascript
+// scripts/init.js
+import init from '@jsarc/initiator';
+
+// Initialiser avec le répertoire du projet
+init(process.cwd());
+
+console.log('✅ Initialisation terminée !');
+```
+
+### Exemple 2 : Personnalisation avancée
+```typescript
+// scripts/custom-init.ts
+import { RouteGenerator } 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'
+};
+
+const generator = new RouteGenerator(customConfig);
+await generator.generate();
+```
+
+### Exemple 3 : Intégration avec un build personnalisé
+```json
+{
+  "scripts": {
+    "dev": "vite",
+    "build": "npm run generate && vite build",
+    "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"
+  }
+}
+```
+
+## 🔧 Configuration Avancée
+
+### Configuration de la traduction
+```typescript
+const translationConfig = {
+  srcDir: './src',
+  supportedLocales: ['en', 'fr', 'es'], // Langues supportées
+  outputFile: './src/auto-intl.ts',
+  modulesDir: './src/modules',
+  localesDir: './src/locales'
+};
+```
+
+### Configuration du routage
+```typescript
+const routeConfig = {
+  srcDir: './src',
+  modulesDir: './src/modules',
+  pagesDir: './src/pages', // Ou 'views', 'screens', etc.
+  outputFile: './src/auto-routes.tsx',
+  layoutFileName: '_layout', // Fichier de layout
+  errorFileName: '_error',   // Fichier d'erreur
+  notFoundFileName: '_404'   // Fichier 404
+};
+```
+
+### Fichier config.json racine
+```json
+{
+  "name": "Mon Application",
+  "version": "1.0.0",
+  "description": "Description de l'application",
+  "author": "Votre Nom",
+  "defaultLocale": "fr",
+  "supportedLocales": ["fr", "en"],
+  "apiUrl": "https://api.example.com",
+  "features": {
+    "auth": true,
+    "analytics": false,
+    "pwa": true
+  }
+}
+```
+
+### Fichier config.json de module
+```json
+{
+  "name": "Module Admin",
+  "description": "Module d'administration",
+  "author": "Équipe Admin",
+  "version": "1.0.0",
+  "routePrefix": "/admin",
+  "isEnabled": true,
+  "dependencies": ["auth"],
+  "permissions": ["admin", "superuser"]
+}
+```
+
+## 📁 Conventions de Fichiers
+
+### Pages spéciales
+| Fichier | Description | Route générée |
+|---------|-------------|---------------|
+| `_layout.tsx` | Layout du dossier | Non accessible directement |
+| `_error.tsx` | Page d'erreur | Utilisée comme errorElement |
+| `_404.tsx` | Page non trouvée | Route catch-all |
+| `[param].tsx` | Route paramétrée | `/:param` |
+| `[...slug].tsx` | Route catch-all | `/*` |
+| `index.tsx` | Page d'index | `/` ou `/dossier/` |
+
+### Structure de module
+```
+modules/
+└── nom-du-module/
+    ├── config.json         # Configuration du module
+    ├── locales/            # Traductions du module
+    │   ├── en.json
+    │   └── fr.json
+    ├── pages/              # Pages du module
+    │   ├── _layout.tsx     # Layout du module
+    │   ├── _error.tsx      # Erreur du module
+    │   ├── _404.tsx        # 404 du module
+    │   └── index.tsx       # Page d'accueil du module
+    └── components/         # Composants du module (optionnel)
+```
+
+## 🔄 Workflow de Développement
+
+### 1. Initialisation du projet
+```bash
+# Créer un nouveau projet
+npm create vite@latest mon-app -- --template react-ts
+cd mon-app
+
+# Installer l'initiator
+npm install @jsarc/initiator
+
+# Générer la structure initiale
+npx @jsarc/initiator
+```
+
+### 2. Ajout d'un nouveau module
+```bash
+# Créer la structure du module
+mkdir -p src/modules/admin/{locales,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
+
+# Régénérer les fichiers
+npx @jsarc/initiator
+```
+
+### 3. Développement avec hot-reload
+```bash
+# Démarrer le serveur de développement
+npm run dev
+
+# Dans un autre terminal, surveiller les changements
+npx @jsarc/initiator --watch
+```
+
+## 🛠️ Intégration avec d'autres outils
+
+### Avec Vite
+```javascript
+// vite.config.js
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  build: {
+    rollupOptions: {
+      external: ['@jsarc/initiator']
+    }
+  }
+});
+```
+
+### Avec Next.js (Adaptation)
+```javascript
+// next.config.js
+const { generateRoutes } = require('@jsarc/initiator/adapters/next');
+
+module.exports = {
+  async rewrites() {
+    const routes = await generateRoutes();
+    return routes.map(route => ({
+      source: route.path,
+      destination: route.filePath
+    }));
+  }
+};
+```
+
+### Avec Webpack
+```javascript
+// webpack.config.js
+const { GenerateRoutesPlugin } = require('@jsarc/initiator/webpack');
+
+module.exports = {
+  plugins: [
+    new GenerateRoutesPlugin({
+      watch: process.env.NODE_ENV === 'development'
+    })
+  ]
+};
+```
+
+## 🐛 Dépannage
+
+### Problèmes courants
+
+1. **"Cannot find module"**
+   ```bash
+   # Réinstaller le plugin
+   npm install @jsarc/initiator
+   ```
+
+2. **Fichiers non générés**
+   ```bash
+   # Forcer la régénération
+   npx @jsarc/initiator --force
+   
+   # Vérifier les permissions
+   chmod +x node_modules/.bin/arc-init
+   ```
+
+3. **Erreurs TypeScript**
+   ```bash
+   # Vérifier les types
+   npm run type-check
+   
+   # Régénérer les fichiers
+   npx @jsarc/initiator
+   ```
+
+### Logs de débogage
+```bash
+# Activer les logs détaillés
+DEBUG=jsarc:* npx @jsarc/initiator
+
+# Sauvegarder les logs dans un fichier
+npx @jsarc/initiator 2>&1 | tee init.log
+```
+
+## 📄 Licence
+
+MIT License - Voir le fichier [LICENSE](LICENSE) pour plus de détails.
+
+## 🤝 Contribution
+
+Les contributions sont les bienvenues ! Pour contribuer :
+
+1. Fork le projet
+2. Créer une branche (`git checkout -b feature/amazing-feature`)
+3. Commit vos changements (`git commit -m 'Add amazing feature'`)
+4. Push vers la branche (`git push origin feature/amazing-feature`)
+5. Ouvrir une Pull Request
+
+## 🐛 Signaler un Bug
+
+Envoyez nous un mail à l'adresse `contact.inicode@gmail.com` pour :
+- Signaler un bug
+- Proposer une amélioration
+- Poser une question
+
+---
+
+**@jsarc/initiator** - Le plugin d'initialisation intelligent pour React et TypeScript.
+
+*Développé par l'équipe INICODE*

package/config.ts

@@ -0,0 +1,153 @@
+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 ConfigGeneratorOptions {
+    srcDir: string;
+    outputFile: string;
+    modulesDir: string;
+    rootConfigPath: string;
+    projectRoot: string;
+}
+
+export class ConfigGenerator {
+    private config: ConfigGeneratorOptions;
+    private modules: Set<string> = new Set();
+
+    constructor(
+        config: Partial<ConfigGeneratorOptions> = {},
+        dirname: string | undefined = __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);
+    }
+
+    public async generate(): Promise<void> {
+        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(', ')}`);
+    }
+
+    private async discoverModules(): Promise<void> {
+        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);
+        }
+    }
+
+    private async generateAutoConfigFile(): 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;
+        }
+
+        return importPath;
+    }
+
+    private generateFileContent(): string {
+        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: string | undefined = __dirname
+) {
+    const config: Partial<ConfigGeneratorOptions> = {};
+
+    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/index.ts

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