@arc-js/initiator 0.0.6 → 0.0.8

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,433 @@ 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 {
+                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 = {
+                    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);
+            }
+        });
+    }
+    convertFilePathToRoutePath(filePath, moduleName) {
+        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;
+    }
+    extractComponentName(filePath, moduleName) {
+        const fileName = path.basename(filePath, path.extname(filePath));
+        const dirName = path.dirname(filePath);
+        const parentDirs = dirName.split(path.sep).filter(dir => dir && dir !== 'src' && dir !== 'modules' && dir !== 'pages' && dir !== moduleName);
+        let componentName = moduleName ? this.toPascalCase(moduleName) : '';
+        parentDirs.forEach(dir => {
+            if (dir !== 'pages') {
+                componentName += this.toPascalCase(dir);
+            }
+        });
+        let cleanedFileName = fileName;
+        if (fileName.startsWith('{') && fileName.endsWith('}')) {
+            const paramName = fileName.substring(1, fileName.length - 1);
+            cleanedFileName = `${this.toPascalCase(paramName)}Params`;
+        }
+        else {
+            cleanedFileName = this.toPascalCase(fileName);
+        }
+        if (!cleanedFileName.endsWith('Page')) {
+            cleanedFileName += 'Page';
+        }
+        return componentName + cleanedFileName;
+    }
+    toPascalCase(str) {
+        return str
+            .split(/[-_]/)
+            .map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+            .join('');
+    }
+    findLayoutComponent(filePath, moduleName) {
+        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;
+    }
+    findErrorComponent(filePath, moduleName) {
+        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;
+    }
+    findNotFoundComponent(filePath, moduleName) {
+        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;
+    }
+    generateComponentName(filePath, moduleName, suffix) {
+        if (!moduleName) {
+            return suffix;
+        }
+        const relativePath = path.relative(path.join(this.config.modulesDir, moduleName, 'pages'), path.dirname(filePath));
+        let componentName = this.toPascalCase(moduleName);
+        if (relativePath && relativePath !== '.') {
+            const dirNames = relativePath.split(path.sep).filter(dir => dir && dir !== '.');
+            dirNames.forEach(dir => {
+                componentName += this.toPascalCase(dir);
+            });
+        }
+        return componentName + suffix;
+    }
+    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;
+    }
+    generateFileContent() {
+        const components = new Set();
+        const imports = [
+            `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 moduleComponents = new Map();
+        this.routeFiles.forEach(route => {
+            if (route.layoutComponent && !components.has(route.layoutComponent)) {
+                components.add(route.layoutComponent);
+                const layoutFile = this.findComponentFile(route.filePath, this.config.layoutFileName, route.moduleName);
+                if (layoutFile) {
+                    const importPath = this.getRelativeImportPath(layoutFile);
+                    imports.push(`const ${route.layoutComponent} = lazy(() => import('${importPath}'));`);
+                }
+            }
+            if (route.errorComponent && !components.has(route.errorComponent)) {
+                components.add(route.errorComponent);
+                const errorFile = this.findComponentFile(route.filePath, this.config.errorFileName, route.moduleName);
+                if (errorFile) {
+                    const importPath = this.getRelativeImportPath(errorFile);
+                    imports.push(`const ${route.errorComponent} = lazy(() => import('${importPath}'));`);
+                }
+            }
+            if (route.notFoundComponent && !components.has(route.notFoundComponent)) {
+                components.add(route.notFoundComponent);
+                const notFoundFile = this.findComponentFile(route.filePath, this.config.notFoundFileName, route.moduleName);
+                if (notFoundFile) {
+                    const importPath = this.getRelativeImportPath(notFoundFile);
+                    imports.push(`const ${route.notFoundComponent} = lazy(() => import('${importPath}'));`);
+                }
+            }
+            const importPath = this.getRelativeImportPath(route.filePath);
+            imports.push(`const ${route.componentName} = lazy(() => import('${importPath}'));`);
+            components.add(route.componentName);
+            if (route.moduleName) {
+                if (!moduleComponents.has(route.moduleName)) {
+                    moduleComponents.set(route.moduleName, new Set());
+                }
+                moduleComponents.get(route.moduleName).add(route.componentName);
+            }
+        });
+        imports.push(``);
+        const routes = ['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;
+        });
+        sortedRoutes.forEach((route, index) => {
+            var _a;
+            const routeLines = ['  {'];
+            routeLines.push(`    path: '${route.routePath}',`);
+            if (route.layoutComponent) {
+                routeLines.push(`    element: <${route.layoutComponent}><${route.componentName} /></${route.layoutComponent}>,`);
+            }
+            else {
+                routeLines.push(`    element: <${route.componentName} />,`);
+            }
+            if (route.errorComponent) {
+                routeLines.push(`    errorElement: <${route.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] += ',';
+            }
+            if (route.moduleName && (index === 0 ||
+                ((_a = sortedRoutes[index - 1]) === null || _a === void 0 ? void 0 : _a.moduleName) !== route.moduleName)) {
+                routes.push(`  // ${route.moduleName} module routes`);
+            }
+            routes.push(routeLines.join('\n'));
+        });
+        const modulesWith404 = new Set();
+        this.routeFiles.forEach(route => {
+            if (route.notFoundComponent && route.moduleName && !modulesWith404.has(route.moduleName)) {
+                modulesWith404.add(route.moduleName);
+                routes.push(`,`);
+                routes.push(`  {`);
+                routes.push(`    path: '/${route.moduleName}/*',`);
+                routes.push(`    element: <${route.notFoundComponent} />`);
+                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: '*',`);
+            routes.push(`    element: <NotFound />`);
+            routes.push(`  }`);
+        }
+        routes.push('];');
+        routes.push('');
+        routes.push('export default routes;');
+        return [
+            ...imports,
+            '',
+            ...routes
+        ].join('\n');
+    }
+    findComponentFile(startPath, fileName, moduleName) {
+        const dir = path.dirname(startPath);
+        let currentDir = dir;
+        while (currentDir !== this.config.srcDir && currentDir !== path.dirname(this.config.srcDir)) {
+            const componentPath = path.join(currentDir, `${fileName}.tsx`);
+            if (fs.existsSync(componentPath)) {
+                return componentPath;
+            }
+            if (moduleName) {
+                const modulePath = path.join(this.config.modulesDir, moduleName);
+                if (currentDir === modulePath) {
+                    break;
+                }
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        if (!moduleName) {
+            const globalPath = path.join(this.config.pagesDir, `${fileName}.tsx`);
+            if (fs.existsSync(globalPath)) {
+                return globalPath;
+            }
+        }
+        return undefined;
+    }
+}
+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 };