apiforge-analyzer 1.1.0

package/dist/cjs/frameworks/nextjs-app.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * Next.js App Router analyzer
+ * Analyzes route handlers in app directory
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeNextApp = analyzeNextApp;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const export_js_1 = require("../export.js");
+const uploader_js_1 = require("../uploader.js");
+/**
+ * Analyze Next.js App Router routes
+ */
+async function analyzeNextApp(options = 'app') {
+    // Support both string path and options object
+    const appDir = typeof options === 'string' ? options : (options.appDir || 'app');
+    const opts = typeof options === 'string' ? { projectName: '' } : options;
+    const routes = [];
+    try {
+        const baseDir = path.join(process.cwd(), appDir);
+        if (!fs.existsSync(baseDir)) {
+            console.warn('app directory not found');
+            return routes;
+        }
+        // Recursively scan for route.ts/route.js files
+        const scanDir = (dir, basePath = '') => {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    // Handle dynamic routes like [id]
+                    const dirName = entry.name.startsWith('[') && entry.name.endsWith(']')
+                        ? `:${entry.name.slice(1, -1)}`
+                        : entry.name;
+                    // Skip non-route directories
+                    if (['_components', '_lib', '_utils'].includes(entry.name)) {
+                        continue;
+                    }
+                    scanDir(fullPath, `${basePath}/${dirName}`);
+                }
+                else if (entry.isFile() && /route\.(ts|js)$/.test(entry.name)) {
+                    // Found a route file
+                    const content = fs.readFileSync(fullPath, 'utf-8');
+                    const methods = detectAppRouterMethods(content);
+                    methods.forEach(method => {
+                        const pathString = basePath || '/';
+                        const operationId = `${method.toLowerCase()}_${pathString.replace(/[^a-zA-Z0-9]/g, '_').replace(/_+/g, '_').replace(/^_|_$/g, '')}`;
+                        const tags = pathString.startsWith('/api') ? ['api'] : ['app'];
+                        const middleware = detectMiddleware(content);
+                        const authRequired = middleware.includes('auth');
+                        const pathParams = extractParameters(pathString).map(p => p.name);
+                        // Basic static extraction
+                        const queryParams = [];
+                        const queryHits = [...content.matchAll(/searchParams\.get\(['"]([^'"]+)['"]\)/g)];
+                        queryHits.forEach(m => queryParams.push(m[1]));
+                        const requestBodyFields = [];
+                        const bodyDestruct = content.match(/const\s+\{([^}]+)\}\s*=\s*await\s+req\.json\(\)/);
+                        if (bodyDestruct) {
+                            bodyDestruct[1].split(',').map(s => s.trim().split(':')[0]).filter(Boolean).forEach(m => requestBodyFields.push(m));
+                        }
+                        routes.push({
+                            method,
+                            path: pathString,
+                            tag: tags[0] || 'General',
+                            operationId,
+                            summary: `${method} ${pathString}`,
+                            middleware,
+                            authRequired,
+                            pathParams: Array.from(new Set(pathParams)),
+                            queryParams: Array.from(new Set(queryParams)),
+                            requestBodyFields: Array.from(new Set(requestBodyFields)),
+                            linkedPaths: [],
+                            hasAuth: authRequired,
+                            framework: 'nextjs-app'
+                        });
+                    });
+                }
+            }
+        };
+        scanDir(baseDir);
+        console.log(`✅ Found ${routes.length} routes`);
+        // Export to JSON if requested
+        if (opts.saveJson && opts.projectName) {
+            const filePath = opts.jsonPath || 'api-export.json';
+            await (0, export_js_1.exportToJSON)(routes, opts.projectName, filePath, opts.baseUrl);
+        }
+        // Upload to APIForge if requested
+        if (opts.upload && opts.apiKey && opts.projectName) {
+            await (0, uploader_js_1.uploadRoutes)(routes, {
+                projectName: opts.projectName,
+                apiKey: opts.apiKey,
+                baseUrl: opts.baseUrl,
+                apiForgeUrl: opts.apiForgeUrl
+            });
+        }
+    }
+    catch (error) {
+        console.error('Error analyzing Next.js App routes:', error.message);
+    }
+    return routes;
+}
+/**
+ * Detect exported HTTP method handlers
+ */
+function detectAppRouterMethods(content) {
+    const methods = [];
+    const httpMethods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'];
+    httpMethods.forEach(method => {
+        // Check for export async function METHOD or export function METHOD
+        const regex = new RegExp(`export\\s+(async\\s+)?function\\s+${method}\\s*\\(`, 'g');
+        if (regex.test(content)) {
+            methods.push(method);
+        }
+    });
+    return methods;
+}
+/**
+ * Detect middleware usage
+ */
+function detectMiddleware(content) {
+    const middleware = [];
+    if (content.includes('auth') || content.includes('authenticate')) {
+        middleware.push('auth');
+    }
+    if (content.includes('cors')) {
+        middleware.push('cors');
+    }
+    return middleware;
+}
+/**
+ * Extract parameters from route path
+ */
+function extractParameters(routePath) {
+    const params = [];
+    const paramMatches = routePath.match(/:(\w+)/g) || [];
+    paramMatches.forEach(param => {
+        const name = param.slice(1);
+        params.push({
+            name,
+            in: 'path',
+            required: true,
+            type: 'string',
+            description: `Path parameter: ${name}`
+        });
+    });
+    return params;
+}

package/dist/cjs/frameworks/nextjs-pages.js

@@ -0,0 +1,154 @@
+"use strict";
+/**
+ * Next.js Pages Router analyzer
+ * Analyzes API routes in pages/api directory
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeNextPages = analyzeNextPages;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Analyze Next.js Pages Router API routes
+ */
+async function analyzeNextPages(pagesDir = 'pages/api') {
+    const routes = [];
+    try {
+        const apiDir = path.join(process.cwd(), pagesDir);
+        if (!fs.existsSync(apiDir)) {
+            console.warn('pages/api directory not found');
+            return routes;
+        }
+        // Recursively scan API directory
+        const scanDir = (dir, basePath = '') => {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    // Handle dynamic routes like [id]
+                    const dirName = entry.name.startsWith('[') && entry.name.endsWith(']')
+                        ? `:${entry.name.slice(1, -1)}`
+                        : entry.name;
+                    scanDir(fullPath, `${basePath}/${dirName}`);
+                }
+                else if (entry.isFile() && /\.(ts|js)$/.test(entry.name)) {
+                    // Convert filename to route path
+                    const fileName = entry.name.replace(/\.(ts|js)$/, '');
+                    let routePath = basePath;
+                    if (fileName !== 'index') {
+                        // Handle dynamic params like [id].ts
+                        const paramName = fileName.startsWith('[') && fileName.endsWith(']')
+                            ? `:${fileName.slice(1, -1)}`
+                            : fileName;
+                        routePath += `/${paramName}`;
+                    }
+                    // Read file to detect HTTP methods
+                    const content = fs.readFileSync(fullPath, 'utf-8');
+                    const methods = detectMethods(content);
+                    // Create route for each detected method
+                    methods.forEach(method => {
+                        routes.push({
+                            method,
+                            path: `/api${routePath}`,
+                            description: `${method} /api${routePath}`,
+                            tags: ['api'],
+                            middleware: detectMiddleware(content),
+                            parameters: extractParameters(routePath),
+                            responses: {
+                                '200': { description: 'Successful response' }
+                            }
+                        });
+                    });
+                }
+            }
+        };
+        scanDir(apiDir);
+    }
+    catch (error) {
+        console.error('Error analyzing Next.js Pages routes:', error.message);
+    }
+    return routes;
+}
+/**
+ * Detect HTTP methods in Next.js API route
+ */
+function detectMethods(content) {
+    const methods = new Set();
+    // Check for req.method checks
+    const methodChecks = content.match(/req\.method\s*===?\s*['"`](\w+)['"`]/g) || [];
+    methodChecks.forEach(check => {
+        const match = check.match(/['"`](\w+)['"`]/);
+        if (match)
+            methods.add(match[1]);
+    });
+    // If no explicit methods found, assume it handles all methods
+    if (methods.size === 0) {
+        methods.add('GET');
+        methods.add('POST');
+    }
+    return Array.from(methods);
+}
+/**
+ * Detect middleware usage
+ */
+function detectMiddleware(content) {
+    const middleware = [];
+    // Check for common middleware patterns
+    if (content.includes('auth') || content.includes('authenticate')) {
+        middleware.push('auth');
+    }
+    if (content.includes('cors')) {
+        middleware.push('cors');
+    }
+    return middleware;
+}
+/**
+ * Extract parameters from route path
+ */
+function extractParameters(routePath) {
+    const params = [];
+    const paramMatches = routePath.match(/:(\w+)/g) || [];
+    paramMatches.forEach(param => {
+        const name = param.slice(1);
+        params.push({
+            name,
+            in: 'path',
+            required: true,
+            type: 'string',
+            description: `Path parameter: ${name}`
+        });
+    });
+    return params;
+}

package/dist/cjs/frameworks/react-router.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * React Router analyzer
+ * Analyzes React Router route definitions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeReactRouter = analyzeReactRouter;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Analyze React Router routes
+ */
+async function analyzeReactRouter(routesFile = 'src/routes.tsx') {
+    const routes = [];
+    try {
+        const routesPath = path.join(process.cwd(), routesFile);
+        if (!fs.existsSync(routesPath)) {
+            console.warn(`Routes file not found: ${routesFile}`);
+            return routes;
+        }
+        const content = fs.readFileSync(routesPath, 'utf-8');
+        // Extract routes from React Router
+        // Look for <Route path="/..." />
+        const routeRegex = /<Route\s+path=["']([^"']+)["']/g;
+        let match;
+        while ((match = routeRegex.exec(content)) !== null) {
+            const routePath = match[1];
+            routes.push({
+                method: 'GET',
+                path: routePath,
+                description: `React Router: ${routePath}`,
+                tags: ['frontend'],
+                middleware: [],
+                parameters: extractParameters(routePath),
+                responses: {
+                    '200': { description: 'Page rendered' }
+                }
+            });
+        }
+        // Also check for createBrowserRouter routes
+        const browserRouterRegex = /path:\s*["']([^"']+)["']/g;
+        while ((match = browserRouterRegex.exec(content)) !== null) {
+            const routePath = match[1];
+            if (!routes.find(r => r.path === routePath)) {
+                routes.push({
+                    method: 'GET',
+                    path: routePath,
+                    description: `React Router: ${routePath}`,
+                    tags: ['frontend'],
+                    middleware: [],
+                    parameters: extractParameters(routePath),
+                    responses: {
+                        '200': { description: 'Page rendered' }
+                    }
+                });
+            }
+        }
+        console.log(`✅ Found ${routes.length} React Router routes`);
+    }
+    catch (error) {
+        console.error('Error analyzing React Router:', error.message);
+    }
+    return routes;
+}
+/**
+ * Extract parameters from route path
+ */
+function extractParameters(routePath) {
+    const params = [];
+    const paramMatches = routePath.match(/:(\w+)/g) || [];
+    paramMatches.forEach(param => {
+        const name = param.slice(1);
+        params.push({
+            name,
+            in: 'path',
+            required: true,
+            type: 'string',
+            description: `Path parameter: ${name}`
+        });
+    });
+    return params;
+}

package/dist/cjs/frameworks/vite.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Vite analyzer
+ * Analyzes Vite projects with API proxy configurations
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeVite = analyzeVite;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Analyze Vite API proxy routes
+ */
+async function analyzeVite(viteConfigPath = 'vite.config.js') {
+    const routes = [];
+    try {
+        const configPath = path.join(process.cwd(), viteConfigPath);
+        if (!fs.existsSync(configPath)) {
+            console.warn('vite.config.js not found');
+            return routes;
+        }
+        const content = fs.readFileSync(configPath, 'utf-8');
+        // Extract proxy configurations
+        const proxyRegex = /proxy:\s*{([^}]+)}/gs;
+        const proxyMatch = content.match(proxyRegex);
+        if (proxyMatch) {
+            const proxyContent = proxyMatch[0];
+            // Extract proxy routes like '/api': { target: 'http://localhost:3000' }
+            const routeRegex = /['"`]([^'"`]+)['"`]\s*:\s*{/g;
+            let match;
+            while ((match = routeRegex.exec(proxyContent)) !== null) {
+                const proxyPath = match[1];
+                // Create route entry
+                routes.push({
+                    method: 'ALL',
+                    path: proxyPath,
+                    description: `Vite proxy: ${proxyPath}`,
+                    tags: ['proxy'],
+                    middleware: [],
+                    responses: {
+                        '200': { description: 'Proxied response' }
+                    }
+                });
+            }
+        }
+        console.log(`✅ Found ${routes.length} Vite proxy routes`);
+    }
+    catch (error) {
+        console.error('Error analyzing Vite config:', error.message);
+    }
+    return routes;
+}

package/dist/cjs/index.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * Main analyzer entry point with dual module support
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFramework = exports.uploadRoutes = exports.exportToJSON = exports.analyzeReactRouter = exports.analyzeVite = exports.analyzeNextApp = exports.analyzeNextPages = exports.analyzeExpress = void 0;
+exports.analyze = analyze;
+const express_js_1 = require("./frameworks/express.js");
+Object.defineProperty(exports, "analyzeExpress", { enumerable: true, get: function () { return express_js_1.analyzeExpress; } });
+const nextjs_pages_js_1 = require("./frameworks/nextjs-pages.js");
+Object.defineProperty(exports, "analyzeNextPages", { enumerable: true, get: function () { return nextjs_pages_js_1.analyzeNextPages; } });
+const nextjs_app_js_1 = require("./frameworks/nextjs-app.js");
+Object.defineProperty(exports, "analyzeNextApp", { enumerable: true, get: function () { return nextjs_app_js_1.analyzeNextApp; } });
+const vite_js_1 = require("./frameworks/vite.js");
+Object.defineProperty(exports, "analyzeVite", { enumerable: true, get: function () { return vite_js_1.analyzeVite; } });
+const react_router_js_1 = require("./frameworks/react-router.js");
+Object.defineProperty(exports, "analyzeReactRouter", { enumerable: true, get: function () { return react_router_js_1.analyzeReactRouter; } });
+const detect_js_1 = require("./detect.js");
+const export_js_1 = require("./export.js");
+const uploader_js_1 = require("./uploader.js");
+// Global state for debouncing
+const analysisState = new Map();
+const DEBOUNCE_TIME = 5000;
+/**
+ * Main analyze function with auto-detection
+ */
+async function analyze(app, options) {
+    // Skip in production
+    if (options.skipInProduction !== false && process.env.NODE_ENV === 'production') {
+        console.log('⏭️  Skipping analysis in production');
+        return [];
+    }
+    // Debounce check
+    if (options.runOnce !== false) {
+        const cached = analysisState.get(options.projectName);
+        const now = Date.now();
+        if (cached && (now - cached.timestamp) < DEBOUNCE_TIME) {
+            console.log(`⚡ Analysis skipped - already ran ${Math.round((now - cached.timestamp) / 1000)}s ago`);
+            return cached.routes;
+        }
+    }
+    console.log(`🔍 Analyzing ${options.projectName}...`);
+    // CRITICAL: Prevent restart loops - force saveJson=false when uploading
+    if (options.upload !== false && options.apiKey) {
+        options.saveJson = false;
+    }
+    let routes = [];
+    let framework = options.framework;
+    // Auto-detect framework if not specified
+    if (!framework) {
+        const detected = (0, detect_js_1.detectFramework)(app);
+        framework = detected.name;
+        console.log(`📦 Detected framework: ${framework}`);
+    }
+    // Analyze based on framework
+    switch (framework) {
+        case 'express':
+            if (!app) {
+                console.error('❌ Express app instance required');
+                return [];
+            }
+            routes = await (0, express_js_1.analyzeExpress)(app);
+            break;
+        case 'nextjs-pages':
+            routes = await (0, nextjs_pages_js_1.analyzeNextPages)(options.nextDir || 'pages/api');
+            break;
+        case 'nextjs-app':
+            routes = await (0, nextjs_app_js_1.analyzeNextApp)(options.nextDir || 'app');
+            break;
+        case 'vite':
+            routes = await (0, vite_js_1.analyzeVite)(options.nextDir || 'vite.config.js');
+            break;
+        case 'react-router':
+            routes = await (0, react_router_js_1.analyzeReactRouter)(options.nextDir || 'src/routes.tsx');
+            break;
+        case 'node-http':
+        case 'unknown':
+        default:
+            console.warn(`⚠️  Framework "${framework}" not supported yet`);
+            console.log('💡 Supported: express, nextjs-pages, nextjs-app, vite, react-router');
+            console.log('💡 Tip: Specify framework manually: { framework: "express" }');
+            return [];
+    }
+    console.log(`✅ Found ${routes.length} routes`);
+    // Cache results
+    if (options.runOnce !== false) {
+        analysisState.set(options.projectName, {
+            timestamp: Date.now(),
+            routes
+        });
+    }
+    // Save JSON (only if not uploading)
+    if (options.saveJson) {
+        const filePath = options.jsonPath || 'api-export.json';
+        await (0, export_js_1.exportToJSON)(routes, options.projectName, filePath, options.baseUrl);
+    }
+    // Upload to APIForge
+    if (options.upload !== false && options.apiKey) {
+        await (0, uploader_js_1.uploadRoutes)(routes, {
+            projectName: options.projectName,
+            apiKey: options.apiKey,
+            baseUrl: options.baseUrl,
+            apiForgeUrl: options.apiForgeUrl,
+        });
+    }
+    return routes;
+}
+var export_js_2 = require("./export.js");
+Object.defineProperty(exports, "exportToJSON", { enumerable: true, get: function () { return export_js_2.exportToJSON; } });
+var uploader_js_2 = require("./uploader.js");
+Object.defineProperty(exports, "uploadRoutes", { enumerable: true, get: function () { return uploader_js_2.uploadRoutes; } });
+var detect_js_2 = require("./detect.js");
+Object.defineProperty(exports, "detectFramework", { enumerable: true, get: function () { return detect_js_2.detectFramework; } });
+// Default export for CommonJS
+exports.default = {
+    analyze,
+    analyzeExpress: express_js_1.analyzeExpress,
+    analyzeNextPages: nextjs_pages_js_1.analyzeNextPages,
+    analyzeNextApp: nextjs_app_js_1.analyzeNextApp,
+    analyzeVite: vite_js_1.analyzeVite,
+    analyzeReactRouter: react_router_js_1.analyzeReactRouter,
+    exportToJSON: export_js_1.exportToJSON,
+    uploadRoutes: uploader_js_1.uploadRoutes,
+    detectFramework: detect_js_1.detectFramework
+};

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}