vitek-plugin 0.1.0-beta

package/dist/core/context/create-context.js

@@ -0,0 +1,34 @@
+/**
+ * Context creation for route handlers
+ * Core logic - runtime agnostic
+ */
+/**
+ * Type guard to check if a value is a VitekResponse
+ * A VitekResponse is identified by having 'status' (number) or 'headers' (object) properties
+ * Plain objects without these properties are treated as regular JSON responses (backward compatibility)
+ */
+export function isVitekResponse(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+    }
+    // It's a VitekResponse if it has 'status' (number) or 'headers' (object) properties
+    // These are clear indicators of a response object, not a data object
+    const hasStatus = 'status' in value && typeof value.status === 'number';
+    const hasHeaders = 'headers' in value && typeof value.headers === 'object' && value.headers !== null && !Array.isArray(value.headers);
+    return hasStatus || hasHeaders;
+}
+/**
+ * Creates a context from a request and extracted parameters
+ */
+export function createContext(request, params = {}, query = {}) {
+    const url = new URL(request.url, 'http://localhost');
+    return {
+        url: request.url,
+        method: request.method.toLowerCase(),
+        path: url.pathname,
+        query,
+        params,
+        headers: request.headers,
+        body: request.body,
+    };
+}

package/dist/core/file-system/scan-api-dir.d.ts

@@ -0,0 +1,26 @@
+/**
+ * API directory scanner
+ * Core logic - uses Node.js fs but abstracted to be testable
+ */
+import type { ParsedRoute } from '../routing/route-parser.js';
+/**
+ * Information about a found middleware
+ */
+export interface MiddlewareInfo {
+    /** Absolute path of the middleware file */
+    path: string;
+    /** Base pattern calculated from the path (e.g., "posts", "posts/:id", "" for global) */
+    basePattern: string;
+}
+/**
+ * Result of API directory scan
+ */
+export interface ScanResult {
+    routes: ParsedRoute[];
+    middlewares: MiddlewareInfo[];
+}
+/**
+ * Recursively scans a directory looking for route files and middlewares
+ */
+export declare function scanApiDirectory(apiDir: string): ScanResult;
+//# sourceMappingURL=scan-api-dir.d.ts.map

package/dist/core/file-system/scan-api-dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan-api-dir.d.ts","sourceRoot":"","sources":["../../../src/core/file-system/scan-api-dir.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAG9D;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,wFAAwF;IACxF,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,WAAW,EAAE,cAAc,EAAE,CAAC;CAC/B;AAsCD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAiD3D"}

package/dist/core/file-system/scan-api-dir.js

@@ -0,0 +1,83 @@
+/**
+ * API directory scanner
+ * Core logic - uses Node.js fs but abstracted to be testable
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { ROUTE_FILE_PATTERN, MIDDLEWARE_FILE_PATTERN, PARAM_PATTERN } from '../../shared/constants.js';
+import { parseRouteFile } from '../routing/route-parser.js';
+/**
+ * Calculates the base pattern of a middleware based on the path relative to apiDir
+ * Example:
+ * - src/api/middleware.ts -> "" (global)
+ * - src/api/posts/middleware.ts -> "posts"
+ * - src/api/posts/[id]/middleware.ts -> "posts/:id"
+ */
+function calculateMiddlewareBasePattern(middlewarePath, apiDir) {
+    // Get the directory where the middleware is located
+    const middlewareDir = path.dirname(middlewarePath);
+    // Calculate relative path from middleware directory to apiDir
+    const relativePath = path.relative(apiDir, middlewareDir);
+    // If it's at the root (apiDir), it's a global middleware
+    if (!relativePath || relativePath === '.' || relativePath === '') {
+        return '';
+    }
+    // Normalize separators
+    let pattern = relativePath.replace(/\\/g, '/');
+    // Remove leading/trailing slashes
+    pattern = pattern.replace(/^\/+|\/+$/g, '');
+    // Convert [id] to :id and [...ids] to *ids
+    pattern = pattern.replace(PARAM_PATTERN, (match, isCatchAll, paramName) => {
+        if (isCatchAll) {
+            return `*${paramName}`;
+        }
+        return `:${paramName}`;
+    });
+    return pattern;
+}
+/**
+ * Recursively scans a directory looking for route files and middlewares
+ */
+export function scanApiDirectory(apiDir) {
+    const routes = [];
+    const middlewares = [];
+    if (!fs.existsSync(apiDir)) {
+        return { routes, middlewares };
+    }
+    function scanDir(currentDir) {
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                scanDir(fullPath);
+            }
+            else if (entry.isFile()) {
+                // Check if it's a middleware file
+                if (MIDDLEWARE_FILE_PATTERN.test(entry.name)) {
+                    const basePattern = calculateMiddlewareBasePattern(fullPath, apiDir);
+                    middlewares.push({
+                        path: fullPath,
+                        basePattern,
+                    });
+                    continue;
+                }
+                // Check if it's a route file
+                if (ROUTE_FILE_PATTERN.test(entry.name)) {
+                    const parsed = parseRouteFile(fullPath, apiDir);
+                    if (parsed) {
+                        routes.push(parsed);
+                    }
+                }
+            }
+        }
+    }
+    scanDir(apiDir);
+    // Sort middlewares by depth (most generic first, most specific last)
+    // This ensures that when composing, global middlewares come before specific ones
+    middlewares.sort((a, b) => {
+        const aDepth = a.basePattern ? a.basePattern.split('/').length : 0;
+        const bDepth = b.basePattern ? b.basePattern.split('/').length : 0;
+        return aDepth - bDepth;
+    });
+    return { routes, middlewares };
+}

package/dist/core/file-system/watch-api-dir.d.ts

@@ -0,0 +1,18 @@
+/**
+ * API directory watcher
+ * Core logic - abstracted to be runtime agnostic
+ */
+export type FileChangeEvent = 'add' | 'change' | 'unlink';
+export type FileChangeCallback = (event: FileChangeEvent, filePath: string) => void;
+/**
+ * Interface for watcher (allows different implementations)
+ */
+export interface ApiWatcher {
+    close(): void;
+}
+/**
+ * Creates a watcher for the API directory using Node.js fs.watch
+ * Returns a function to stop watching
+ */
+export declare function watchApiDirectory(apiDir: string, callback: FileChangeCallback): ApiWatcher;
+//# sourceMappingURL=watch-api-dir.d.ts.map

package/dist/core/file-system/watch-api-dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch-api-dir.d.ts","sourceRoot":"","sources":["../../../src/core/file-system/watch-api-dir.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAC1D,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;AAEpF;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,kBAAkB,GAC3B,UAAU,CAiCZ"}

package/dist/core/file-system/watch-api-dir.js

@@ -0,0 +1,40 @@
+/**
+ * API directory watcher
+ * Core logic - abstracted to be runtime agnostic
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { ROUTE_FILE_PATTERN, MIDDLEWARE_FILE_PATTERN } from '../../shared/constants.js';
+/**
+ * Creates a watcher for the API directory using Node.js fs.watch
+ * Returns a function to stop watching
+ */
+export function watchApiDirectory(apiDir, callback) {
+    if (!fs.existsSync(apiDir)) {
+        return { close: () => { } };
+    }
+    const watcher = fs.watch(apiDir, { recursive: true }, (eventType, filename) => {
+        if (!filename)
+            return;
+        const filePath = path.join(apiDir, filename);
+        // Ignore if it's not a route file or relevant middleware
+        const isRouteFile = ROUTE_FILE_PATTERN.test(filename);
+        const isMiddlewareFile = MIDDLEWARE_FILE_PATTERN.test(filename);
+        if (!isRouteFile && !isMiddlewareFile) {
+            return;
+        }
+        // Normalize event type
+        let normalizedEvent;
+        if (eventType === 'rename') {
+            // rename can be add or unlink, check if it exists
+            normalizedEvent = fs.existsSync(filePath) ? 'add' : 'unlink';
+        }
+        else {
+            normalizedEvent = eventType;
+        }
+        callback(normalizedEvent, filePath);
+    });
+    return {
+        close: () => watcher.close(),
+    };
+}

package/dist/core/middleware/compose.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Middleware composer (Koa-style)
+ * Core logic - no dependencies
+ */
+import type { Middleware } from '../routing/route-types.js';
+import type { VitekContext } from '../context/create-context.js';
+/**
+ * Composes middlewares into a single function
+ * Executes in order and allows each middleware to call next() to continue
+ */
+export declare function compose(middlewares: Middleware[]): (context: VitekContext, handler: () => Promise<any>) => Promise<any>;
+//# sourceMappingURL=compose.d.ts.map

package/dist/core/middleware/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../../src/core/middleware/compose.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE;;;GAGG;AACH,wBAAgB,OAAO,CAAC,WAAW,EAAE,UAAU,EAAE,IACxB,SAAS,YAAY,EAAE,SAAS,MAAM,OAAO,CAAC,GAAG,CAAC,KAAG,OAAO,CAAC,GAAG,CAAC,CAuBzF"}

package/dist/core/middleware/compose.js

@@ -0,0 +1,27 @@
+/**
+ * Middleware composer (Koa-style)
+ * Core logic - no dependencies
+ */
+/**
+ * Composes middlewares into a single function
+ * Executes in order and allows each middleware to call next() to continue
+ */
+export function compose(middlewares) {
+    return async function (context, handler) {
+        let index = -1;
+        async function dispatch(i) {
+            if (i <= index) {
+                throw new Error('next() called multiple times');
+            }
+            index = i;
+            // If all middlewares have been executed, call the final handler
+            if (i === middlewares.length) {
+                return handler();
+            }
+            const middleware = middlewares[i];
+            // Execute the current middleware
+            await middleware(context, () => dispatch(i + 1));
+        }
+        return dispatch(0);
+    };
+}

package/dist/core/middleware/get-applicable-middlewares.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Determines which middlewares are applicable to a route based on the pattern
+ * Core logic - no dependencies
+ */
+import type { Middleware } from '../routing/route-types.js';
+/**
+ * Information about a loaded middleware (with the middleware function already imported)
+ */
+export interface LoadedMiddleware {
+    middleware: Middleware[];
+    basePattern: string;
+}
+/**
+ * Returns the middlewares applicable to a route, ordered from most generic to most specific
+ */
+export declare function getApplicableMiddlewares(middlewares: LoadedMiddleware[], routePattern: string): Middleware[];
+//# sourceMappingURL=get-applicable-middlewares.d.ts.map

package/dist/core/middleware/get-applicable-middlewares.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-applicable-middlewares.d.ts","sourceRoot":"","sources":["../../../src/core/middleware/get-applicable-middlewares.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAG5D;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,UAAU,EAAE,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;CACrB;AAuCD;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,gBAAgB,EAAE,EAC/B,YAAY,EAAE,MAAM,GACnB,UAAU,EAAE,CAUd"}

package/dist/core/middleware/get-applicable-middlewares.js

@@ -0,0 +1,47 @@
+/**
+ * Determines which middlewares are applicable to a route based on the pattern
+ * Core logic - no dependencies
+ */
+/**
+ * Checks if a middleware base pattern applies to a route pattern
+ * A middleware applies if its basePattern is a prefix of the routePattern
+ *
+ * Examples:
+ * - basePattern: "" → applies to all routes (global)
+ * - basePattern: "posts" → applies to "posts", "posts/:id", "posts/:id/comments", etc
+ * - basePattern: "posts/:id" → applies to "posts/:id", "posts/:id/comments", but not to "posts"
+ */
+function isMiddlewareApplicable(basePattern, routePattern) {
+    // Global middleware (empty basePattern) applies to all routes
+    if (basePattern === '') {
+        return true;
+    }
+    // If route is empty (root), only global middleware applies
+    if (routePattern === '') {
+        return false;
+    }
+    // Normalize patterns for comparison (remove leading/trailing slashes)
+    const normalizedBase = basePattern.replace(/^\/+|\/+$/g, '');
+    const normalizedRoute = routePattern.replace(/^\/+|\/+$/g, '');
+    // Check if basePattern is an exact prefix of routePattern
+    // Or if route starts with basePattern followed by /
+    if (normalizedRoute === normalizedBase) {
+        return true;
+    }
+    if (normalizedRoute.startsWith(normalizedBase + '/')) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Returns the middlewares applicable to a route, ordered from most generic to most specific
+ */
+export function getApplicableMiddlewares(middlewares, routePattern) {
+    const applicable = [];
+    for (const loadedMiddleware of middlewares) {
+        if (isMiddlewareApplicable(loadedMiddleware.basePattern, routePattern)) {
+            applicable.push(...loadedMiddleware.middleware);
+        }
+    }
+    return applicable;
+}

package/dist/core/middleware/load-global.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Global middleware loading
+ * Core logic - runtime agnostic
+ */
+import type { Middleware } from '../routing/route-types.js';
+/**
+ * Loads global middleware from a module
+ * The module must export a default or named export 'middleware'
+ *
+ * @param middlewarePath - Absolute path to the middleware file
+ */
+export declare function loadGlobalMiddleware(middlewarePath: string): Promise<Middleware[]>;
+//# sourceMappingURL=load-global.d.ts.map

package/dist/core/middleware/load-global.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-global.d.ts","sourceRoot":"","sources":["../../../src/core/middleware/load-global.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5D;;;;;GAKG;AACH,wBAAsB,oBAAoB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CA8BxF"}

package/dist/core/middleware/load-global.js

@@ -0,0 +1,37 @@
+/**
+ * Global middleware loading
+ * Core logic - runtime agnostic
+ */
+/**
+ * Loads global middleware from a module
+ * The module must export a default or named export 'middleware'
+ *
+ * @param middlewarePath - Absolute path to the middleware file
+ */
+export async function loadGlobalMiddleware(middlewarePath) {
+    try {
+        // Dynamic import - converts to URL for Vite/Node compatibility
+        const { pathToFileURL } = await import('node:url');
+        const moduleUrl = pathToFileURL(middlewarePath).href;
+        const module = await import(moduleUrl);
+        // Supports both default export and named export
+        const middleware = module.default || module.middleware;
+        if (!middleware) {
+            return [];
+        }
+        // If it's an array, return directly
+        if (Array.isArray(middleware)) {
+            return middleware;
+        }
+        // If it's a single function, return as array
+        if (typeof middleware === 'function') {
+            return [middleware];
+        }
+        return [];
+    }
+    catch (error) {
+        // If file doesn't exist or has no middleware, return empty array
+        // This allows middleware to be optional
+        return [];
+    }
+}

package/dist/core/normalize/normalize-path.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Path normalization for API routes
+ * Core logic - no Vite dependencies
+ */
+/**
+ * Converts a file path to a normalized HTTP route
+ *
+ * Examples:
+ * - users/[id].get.ts -> users/:id
+ * - posts/[...ids].get.ts -> posts/*ids
+ * - health.get.ts -> health
+ */
+export declare function normalizeRoutePath(filePath: string): string;
+/**
+ * Extracts parameters from a path pattern
+ * Example: "users/:id/posts/:postId" -> ["id", "postId"]
+ */
+export declare function extractParamsFromPattern(pattern: string): string[];
+/**
+ * Converts a path pattern to regex for matching
+ * Example: "users/:id" -> /^\/users\/([^/]+)$/
+ * Example: "posts/*ids" -> /^\/posts\/(.*)$/
+ */
+export declare function patternToRegex(pattern: string): RegExp;
+//# sourceMappingURL=normalize-path.d.ts.map

package/dist/core/normalize/normalize-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-path.d.ts","sourceRoot":"","sources":["../../../src/core/normalize/normalize-path.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CA2B3D;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAUlE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA0BtD"}

package/dist/core/normalize/normalize-path.js

@@ -0,0 +1,76 @@
+/**
+ * Path normalization for API routes
+ * Core logic - no Vite dependencies
+ */
+import { PARAM_PATTERN } from '../../shared/constants.js';
+/**
+ * Converts a file path to a normalized HTTP route
+ *
+ * Examples:
+ * - users/[id].get.ts -> users/:id
+ * - posts/[...ids].get.ts -> posts/*ids
+ * - health.get.ts -> health
+ */
+export function normalizeRoutePath(filePath) {
+    // Remove extensions (.ts, .js) and HTTP method
+    let path = filePath
+        .replace(/\.(ts|js)$/, '')
+        .replace(/\.(get|post|put|patch|delete|head|options)$/, '');
+    // Normalize separators
+    path = path.replace(/\\/g, '/');
+    // Remove leading/trailing slashes (but preserve empty string for root route)
+    path = path.replace(/^\/+|\/+$/g, '');
+    // If path is empty, it means root route (e.g., health.get.ts)
+    if (!path) {
+        return '';
+    }
+    // Convert [id] to :id and [...ids] to *ids (catch-all)
+    path = path.replace(PARAM_PATTERN, (match, isCatchAll, paramName) => {
+        if (isCatchAll) {
+            return `*${paramName}`;
+        }
+        return `:${paramName}`;
+    });
+    // Return without normalizing (without adding /), as it will be used in patternToRegex
+    return path;
+}
+/**
+ * Extracts parameters from a path pattern
+ * Example: "users/:id/posts/:postId" -> ["id", "postId"]
+ */
+export function extractParamsFromPattern(pattern) {
+    const params = [];
+    const paramRegex = /[:*]([^/]+)/g;
+    let match;
+    while ((match = paramRegex.exec(pattern)) !== null) {
+        params.push(match[1]);
+    }
+    return params;
+}
+/**
+ * Converts a path pattern to regex for matching
+ * Example: "users/:id" -> /^\/users\/([^/]+)$/
+ * Example: "posts/*ids" -> /^\/posts\/(.*)$/
+ */
+export function patternToRegex(pattern) {
+    // Normalize pattern: empty route becomes '/', others add / at the beginning
+    let normalizedPattern = pattern === '' ? '/' : (pattern.startsWith('/') ? pattern : `/${pattern}`);
+    // First replace placeholders (before escaping)
+    // Replace *param (catch-all) with temporary placeholder
+    normalizedPattern = normalizedPattern.replace(/\*(\w+)/g, '__CATCHALL_$1__');
+    // Replace :param with temporary placeholder
+    normalizedPattern = normalizedPattern.replace(/:(\w+)/g, '__PARAM_$1__');
+    // Escape special characters
+    let regexStr = normalizedPattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+    // Restore placeholders as capture groups
+    regexStr = regexStr.replace(/__PARAM_\w+__/g, '([^/]+)');
+    regexStr = regexStr.replace(/__CATCHALL_(\w+)__/g, '(.*)');
+    // Ensure it starts and ends correctly
+    if (!regexStr.startsWith('^')) {
+        regexStr = '^' + regexStr;
+    }
+    if (!regexStr.endsWith('$')) {
+        regexStr = regexStr + '$';
+    }
+    return new RegExp(regexStr);
+}

package/dist/core/routing/route-matcher.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Route matching against requests
+ * Core logic - no Vite dependencies
+ */
+import type { Route, RouteMatch } from './route-types.js';
+/**
+ * Finds the route that matches a path and method
+ */
+export declare function matchRoute(routes: Route[], path: string, method: string): RouteMatch | null;
+//# sourceMappingURL=route-matcher.d.ts.map

package/dist/core/routing/route-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-matcher.d.ts","sourceRoot":"","sources":["../../../src/core/routing/route-matcher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG1D;;GAEG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,KAAK,EAAE,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACb,UAAU,GAAG,IAAI,CA4BnB"}

package/dist/core/routing/route-matcher.js

@@ -0,0 +1,32 @@
+/**
+ * Route matching against requests
+ * Core logic - no Vite dependencies
+ */
+/**
+ * Finds the route that matches a path and method
+ */
+export function matchRoute(routes, path, method) {
+    // Normalize path ensuring it starts with /
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    const normalizedMethod = method.toLowerCase();
+    // Filter routes by method
+    const methodRoutes = routes.filter(r => r.method === normalizedMethod);
+    // Try to match in order
+    for (const route of methodRoutes) {
+        const match = normalizedPath.match(route.regex);
+        if (match) {
+            // Extract parameters from match
+            const params = {};
+            route.params.forEach((paramName, index) => {
+                // +1 because match[0] is the complete match
+                const value = match[index + 1];
+                params[paramName] = value !== undefined ? value : '';
+            });
+            return {
+                route,
+                params,
+            };
+        }
+    }
+    return null;
+}

package/dist/core/routing/route-parser.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Route file parser
+ * Core logic - no Vite dependencies
+ */
+import type { Route, RouteHandler } from './route-types.js';
+import type { HttpMethod } from '../../shared/constants.js';
+/**
+ * Result of parsing a route file
+ */
+export interface ParsedRoute {
+    method: HttpMethod;
+    pattern: string;
+    params: string[];
+    file: string;
+}
+/**
+ * Extracts route information from a file path
+ *
+ * Examples:
+ * - src/api/users/[id].get.ts -> { method: 'get', pattern: 'users/:id', params: ['id'] }
+ * - src/api/posts/[...ids].get.ts -> { method: 'get', pattern: 'posts/*ids', params: ['ids'] }
+ */
+export declare function parseRouteFile(filePath: string, baseDir: string): ParsedRoute | null;
+/**
+ * Creates a route definition from a parsed route and handler
+ */
+export declare function createRoute(parsed: ParsedRoute, handler: RouteHandler, bodyType?: string, queryType?: string): Route;
+//# sourceMappingURL=route-parser.d.ts.map

package/dist/core/routing/route-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-parser.d.ts","sourceRoot":"","sources":["../../../src/core/routing/route-parser.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CA2BpF;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,KAAK,CAWpH"}

package/dist/core/routing/route-parser.js

@@ -0,0 +1,52 @@
+/**
+ * Route file parser
+ * Core logic - no Vite dependencies
+ */
+import { ROUTE_FILE_PATTERN } from '../../shared/constants.js';
+import { isHttpMethod } from '../../shared/utils.js';
+import { normalizeRoutePath, extractParamsFromPattern, patternToRegex } from '../normalize/normalize-path.js';
+/**
+ * Extracts route information from a file path
+ *
+ * Examples:
+ * - src/api/users/[id].get.ts -> { method: 'get', pattern: 'users/:id', params: ['id'] }
+ * - src/api/posts/[...ids].get.ts -> { method: 'get', pattern: 'posts/*ids', params: ['ids'] }
+ */
+export function parseRouteFile(filePath, baseDir) {
+    // Remove base directory from path
+    const relativePath = filePath.replace(baseDir, '').replace(/^[/\\]/, '');
+    // Try to match route file pattern
+    const match = relativePath.match(ROUTE_FILE_PATTERN);
+    if (!match) {
+        return null;
+    }
+    const [, pathPart, methodPart] = match;
+    const method = methodPart.toLowerCase();
+    if (!isHttpMethod(method)) {
+        return null;
+    }
+    // Normalize path and extract parameters
+    const pattern = normalizeRoutePath(pathPart);
+    const params = extractParamsFromPattern(pattern);
+    return {
+        method,
+        pattern,
+        params,
+        file: filePath,
+    };
+}
+/**
+ * Creates a route definition from a parsed route and handler
+ */
+export function createRoute(parsed, handler, bodyType, queryType) {
+    return {
+        pattern: parsed.pattern,
+        method: parsed.method,
+        handler,
+        params: parsed.params,
+        file: parsed.file,
+        regex: patternToRegex(parsed.pattern),
+        bodyType,
+        queryType,
+    };
+}