@arc-js/initiator 0.0.6 → 0.0.7

package/index.d.ts

@@ -1,3 +1,3 @@
-declare function export_default(dirname?: string | undefined): void;
+declare function export_default(dirname?: string): void;
 
 export { export_default as default };

package/index.js

@@ -194418,10 +194418,10 @@ function requirePajo () {
 
 var pajoExports = requirePajo();
 
-const __filename$2 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
-const __dirname$2 = path.dirname(__filename$2);
+const __filename$3 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
+const __dirname$3 = path.dirname(__filename$3);
 class TranslationGenerator {
-    constructor(config = {}, dirname = __dirname$2) {
+    constructor(config = {}, dirname = __dirname$3) {
         this.keys = [];
         this.modules = new Set();
         this.importedModules = new Set();
@@ -194667,7 +194667,7 @@ export default translations;`;
     }
 }
 function TranslationInitiator() {
-    return __awaiter(this, arguments, void 0, function* (dirname = __dirname$2) {
+    return __awaiter(this, arguments, void 0, function* (dirname = __dirname$3) {
         const config = {};
         const generator = new TranslationGenerator(config, dirname);
         generator.generate().then(() => {
@@ -194678,10 +194678,10 @@ function TranslationInitiator() {
     });
 }
 
-const __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
-const __dirname$1 = path.dirname(__filename$1);
+const __filename$2 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
+const __dirname$2 = path.dirname(__filename$2);
 class ConfigGenerator {
-    constructor(config = {}, dirname = __dirname$1) {
+    constructor(config = {}, dirname = __dirname$2) {
         this.modules = new Set();
         this.config = {
             srcDir: config.srcDir || pajoExports.Pajo.join(dirname, 'src') || '',
@@ -194780,7 +194780,7 @@ export default configs;`;
     }
 }
 function ConfigInitiator() {
-    return __awaiter(this, arguments, void 0, function* (dirname = __dirname$1) {
+    return __awaiter(this, arguments, void 0, function* (dirname = __dirname$2) {
         const config = {};
         const generator = new ConfigGenerator(config, dirname);
         generator.generate().then(() => {
@@ -194791,9 +194791,397 @@ function ConfigInitiator() {
     });
 }
 
+const __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
+const __dirname$1 = path.dirname(__filename$1);
+class RouteGenerator {
+    constructor(config = {}, dirname = __dirname$1) {
+        this.routeFiles = [];
+        this.modules = new Set();
+        this.config = {
+            srcDir: config.srcDir || pajoExports.Pajo.join(dirname, 'src') || '',
+            modulesDir: config.modulesDir || pajoExports.Pajo.join(dirname, 'src\\modules') || '',
+            pagesDir: config.pagesDir || pajoExports.Pajo.join(dirname, 'src\\pages') || '',
+            outputFile: config.outputFile || pajoExports.Pajo.join(dirname, 'src\\auto-routes.ts') || '',
+            layoutFileName: config.layoutFileName || '_layout',
+            errorFileName: config.errorFileName || '_error',
+            notFoundFileName: config.notFoundFileName || '_404'
+        };
+        console.log(`--> RouteGenerator config:: `, this.config);
+    }
+    generate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('🔍 Scanning for route files...');
+            yield this.findRouteFiles();
+            yield this.generateAutoRoutesFile();
+            console.log(`✅ Generated ${this.config.outputFile} with ${this.routeFiles.length} routes`);
+            console.log(`📦 Found modules with routes: ${Array.from(this.modules).join(', ')}`);
+        });
+    }
+    findRouteFiles() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.routeFiles = [];
+            yield 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);
+                        yield this.scanDirectoryForRoutes(modulePagesDir, moduleName);
+                    }
+                }
+            }
+        });
+    }
+    scanDirectoryForRoutes(dir, moduleName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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()) {
+                        yield 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;
+                            }
+                            yield this.processRouteFile(fullPath, moduleName);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Error scanning directory ${dir}:`, error);
+            }
+        });
+    }
+    processRouteFile(filePath, moduleName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const relativePath = path.relative(this.config.srcDir, filePath);
+                let routePath = this.convertFilePathToRoutePath(filePath, moduleName);
+                const componentName = this.extractComponentName(filePath);
+                const hasLayout = this.checkForLayoutFile(filePath, moduleName);
+                const hasError = this.checkForErrorFile(filePath, moduleName);
+                const routeFile = {
+                    filePath,
+                    relativePath,
+                    routePath,
+                    componentName,
+                    hasLayout,
+                    hasError,
+                    moduleName
+                };
+                this.routeFiles.push(routeFile);
+            }
+            catch (error) {
+                console.error(`Error processing route file ${filePath}:`, error);
+            }
+        });
+    }
+    convertFilePathToRoutePath(filePath, moduleName) {
+        let routePath = filePath;
+        routePath = routePath.replace(this.config.srcDir, '');
+        if (moduleName) {
+            routePath = routePath.replace(new RegExp(`modules\\\\${moduleName}\\\\pages`), '');
+            routePath = routePath.replace(new RegExp(`modules/${moduleName}/pages`), '');
+        }
+        else {
+            routePath = routePath.replace(/pages[\\/]/, '');
+        }
+        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 === '/') {
+            return '/';
+        }
+        return routePath;
+    }
+    extractComponentName(filePath) {
+        const fileName = path.basename(filePath, path.extname(filePath));
+        const pascalName = fileName
+            .split(/[-_]/)
+            .map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+            .join('');
+        const reservedNames = ['Layout', 'Error', 'NotFound', 'ErrorBoundary'];
+        const finalName = reservedNames.includes(pascalName) ? `${pascalName}Page` : pascalName;
+        return `${finalName}Page`;
+    }
+    checkForLayoutFile(filePath, moduleName) {
+        const dir = path.dirname(filePath);
+        const layoutPath = path.join(dir, `${this.config.layoutFileName}.tsx`);
+        if (fs.existsSync(layoutPath)) {
+            return true;
+        }
+        let currentDir = dir;
+        while (currentDir !== this.config.srcDir && currentDir !== path.dirname(this.config.srcDir)) {
+            const parentLayoutPath = path.join(currentDir, `${this.config.layoutFileName}.tsx`);
+            if (fs.existsSync(parentLayoutPath)) {
+                return true;
+            }
+            if (moduleName) {
+                const moduleLayoutPath = path.join(this.config.modulesDir, moduleName, 'pages', `${this.config.layoutFileName}.tsx`);
+                if (fs.existsSync(moduleLayoutPath)) {
+                    return true;
+                }
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        const globalLayoutPath = path.join(this.config.pagesDir, `${this.config.layoutFileName}.tsx`);
+        return fs.existsSync(globalLayoutPath);
+    }
+    checkForErrorFile(filePath, moduleName) {
+        const dir = path.dirname(filePath);
+        const errorPath = path.join(dir, `${this.config.errorFileName}.tsx`);
+        if (fs.existsSync(errorPath)) {
+            return true;
+        }
+        let currentDir = dir;
+        while (currentDir !== this.config.srcDir && currentDir !== path.dirname(this.config.srcDir)) {
+            const parentErrorPath = path.join(currentDir, `${this.config.errorFileName}.tsx`);
+            if (fs.existsSync(parentErrorPath)) {
+                return true;
+            }
+            if (moduleName) {
+                const moduleErrorPath = path.join(this.config.modulesDir, moduleName, 'pages', `${this.config.errorFileName}.tsx`);
+                if (fs.existsSync(moduleErrorPath)) {
+                    return true;
+                }
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        const globalErrorPath = path.join(this.config.pagesDir, `${this.config.errorFileName}.tsx`);
+        return fs.existsSync(globalErrorPath);
+    }
+    generateAutoRoutesFile() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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)$/, '');
+        return importPath;
+    }
+    escapeTemplateString(str) {
+        return str
+            .replace(/\\/g, '\\\\') 
+            .replace(/`/g, '\\`') 
+            .replace(/\${/g, '\\${'); 
+    }
+    generateFileContent() {
+        const moduleRoutes = {};
+        const globalRoutes = [];
+        this.routeFiles.forEach(route => {
+            if (route.moduleName) {
+                if (!moduleRoutes[route.moduleName]) {
+                    moduleRoutes[route.moduleName] = [];
+                }
+                moduleRoutes[route.moduleName].push(route);
+            }
+            else {
+                globalRoutes.push(route);
+            }
+        });
+        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`);
+        const hasGlobalLayout = fs.existsSync(globalLayoutPath);
+        const hasGlobalError = fs.existsSync(globalErrorPath);
+        const hasGlobal404 = fs.existsSync(global404Path);
+        const imports = [
+            `import { lazy } from 'react';`,
+            `import type { RouteObject } from 'react-router-dom';`,
+            ``
+        ];
+        if (hasGlobalLayout) {
+            const importPath = this.getRelativeImportPath(globalLayoutPath);
+            imports.push(`const Layout = lazy(() => import('${this.escapeTemplateString(importPath)}'));`);
+        }
+        else {
+            imports.push(`// No global layout found`);
+        }
+        if (hasGlobalError) {
+            const importPath = this.getRelativeImportPath(globalErrorPath);
+            imports.push(`const ErrorBoundary = lazy(() => import('${this.escapeTemplateString(importPath)}'));`);
+        }
+        else {
+            imports.push(`// No global error boundary found`);
+        }
+        if (hasGlobal404) {
+            const importPath = this.getRelativeImportPath(global404Path);
+            imports.push(`const NotFound = lazy(() => import('${this.escapeTemplateString(importPath)}'));`);
+        }
+        else {
+            imports.push(`// No 404 page found`);
+        }
+        imports.push(``);
+        Object.keys(moduleRoutes).forEach(moduleName => {
+            const moduleLayoutPath = path.join(this.config.modulesDir, moduleName, 'pages', `${this.config.layoutFileName}.tsx`);
+            const moduleErrorPath = path.join(this.config.modulesDir, moduleName, 'pages', `${this.config.errorFileName}.tsx`);
+            const hasModuleLayout = fs.existsSync(moduleLayoutPath);
+            const hasModuleError = fs.existsSync(moduleErrorPath);
+            if (hasModuleLayout) {
+                const importPath = this.getRelativeImportPath(moduleLayoutPath);
+                imports.push(`const ${moduleName}Layout = lazy(() => import('${this.escapeTemplateString(importPath)}'));`);
+            }
+            else {
+                imports.push(`// No layout found for ${moduleName} module`);
+            }
+            if (hasModuleError) {
+                const importPath = this.getRelativeImportPath(moduleErrorPath);
+                imports.push(`const ${moduleName}ErrorBoundary = lazy(() => import('${this.escapeTemplateString(importPath)}'));`);
+            }
+            else {
+                imports.push(`// No error boundary found for ${moduleName} module`);
+            }
+            imports.push(``);
+        });
+        if (globalRoutes.length > 0) {
+            imports.push(`// Global routes imports`);
+            globalRoutes.forEach(route => {
+                const importPath = this.getRelativeImportPath(route.filePath);
+                imports.push(`const ${route.componentName} = lazy(() => import('${this.escapeTemplateString(importPath)}'));`);
+            });
+            imports.push(``);
+        }
+        Object.entries(moduleRoutes).forEach(([moduleName, routes]) => {
+            if (routes.length > 0) {
+                imports.push(`// ${moduleName} module imports`);
+                routes.forEach(route => {
+                    const importPath = this.getRelativeImportPath(route.filePath);
+                    imports.push(`const ${route.componentName} = lazy(() => import('${this.escapeTemplateString(importPath)}'));`);
+                });
+                imports.push(``);
+            }
+        });
+        const routes = ['export const routes: RouteObject[] = ['];
+        if (globalRoutes.length > 0) {
+            globalRoutes.forEach((route, index) => {
+                const routeObj = ['  {'];
+                routeObj.push(`    path: '${route.routePath.replace(/'/g, "\\'")}',`);
+                if (route.hasLayout && hasGlobalLayout) {
+                    routeObj.push(`    element: <Layout><${route.componentName} /></Layout>,`);
+                }
+                else {
+                    routeObj.push(`    element: <${route.componentName} />,`);
+                }
+                if (route.hasError && hasGlobalError) {
+                    routeObj.push(`    errorElement: <ErrorBoundary />`);
+                }
+                const lastLine = routeObj[routeObj.length - 1];
+                if (!lastLine.endsWith(',')) {
+                    routeObj[routeObj.length - 1] = lastLine + ',';
+                }
+                routeObj.push('  }');
+                if (index < globalRoutes.length - 1 || Object.keys(moduleRoutes).length > 0) {
+                    routeObj[routeObj.length - 1] += ',';
+                }
+                routes.push(routeObj.join('\n'));
+            });
+        }
+        Object.entries(moduleRoutes).forEach(([moduleName, moduleRoutesList], moduleIndex) => {
+            if (moduleRoutesList.length > 0) {
+                if (globalRoutes.length > 0 || moduleIndex > 0) {
+                    routes.push('');
+                }
+                routes.push(`  // ${moduleName} module routes`);
+                moduleRoutesList.forEach((route, routeIndex) => {
+                    const routeObj = ['  {'];
+                    routeObj.push(`    path: '${route.routePath.replace(/'/g, "\\'")}',`);
+                    const hasModuleLayout = fs.existsSync(path.join(this.config.modulesDir, moduleName, 'pages', `${this.config.layoutFileName}.tsx`));
+                    const hasModuleError = fs.existsSync(path.join(this.config.modulesDir, moduleName, 'pages', `${this.config.errorFileName}.tsx`));
+                    if (route.hasLayout && hasModuleLayout) {
+                        routeObj.push(`    element: <${moduleName}Layout><${route.componentName} /></${moduleName}Layout>,`);
+                    }
+                    else {
+                        routeObj.push(`    element: <${route.componentName} />,`);
+                    }
+                    if (route.hasError && hasModuleError) {
+                        routeObj.push(`    errorElement: <${moduleName}ErrorBoundary />`);
+                    }
+                    const lastLine = routeObj[routeObj.length - 1];
+                    if (!lastLine.endsWith(',')) {
+                        routeObj[routeObj.length - 1] = lastLine + ',';
+                    }
+                    routeObj.push('  }');
+                    const isLastModule = moduleIndex === Object.keys(moduleRoutes).length - 1;
+                    const isLastRoute = routeIndex === moduleRoutesList.length - 1;
+                    if (!(isLastModule && isLastRoute && !hasGlobal404)) {
+                        routeObj[routeObj.length - 1] += ',';
+                    }
+                    routes.push(routeObj.join('\n'));
+                });
+            }
+        });
+        if (hasGlobal404) {
+            if (globalRoutes.length > 0 || Object.keys(moduleRoutes).length > 0) {
+                routes.push('');
+            }
+            routes.push('  // 404 page');
+            routes.push('  {');
+            routes.push(`    path: '*',`);
+            routes.push(`    element: <NotFound />`);
+            routes.push('  }');
+        }
+        routes.push('];');
+        routes.push('');
+        routes.push('export default routes;');
+        return [
+            ...imports,
+            '',
+            ...routes
+        ].join('\n');
+    }
+}
+function RouteInitiator() {
+    return __awaiter(this, arguments, void 0, function* (dirname = __dirname$1) {
+        const config = {};
+        const generator = new RouteGenerator(config, dirname);
+        try {
+            yield generator.generate();
+            console.log('🎉 Route generation completed successfully!');
+        }
+        catch (err) {
+            console.error('❌ Failed to generate routes: ', err);
+        }
+    });
+}
+
 function index (dirname = __dirname) {
     TranslationInitiator(dirname);
     ConfigInitiator(dirname);
+    RouteInitiator(dirname);
 }
 
 module.exports = index;

package/index.min.d.ts

@@ -1,3 +1,3 @@
-declare function export_default(dirname?: string | undefined): void;
+declare function export_default(dirname?: string): void;
 
 export { export_default as default };