@kimesh/router-generator 0.2.8 → 0.2.9

package/dist/index.d.mts

@@ -417,6 +417,15 @@ interface LayerRouteNode extends RouteNode {
  */
 declare function collectLayerRoutes(sources: LayerRouteSource[], config: ResolvedRouterConfig): Promise<LayerRoutesResult>;
 //#endregion
+//#region src/route-merger.d.ts
+/**
+ * Merge app routes with layer routes
+ * App routes (priority 0) take precedence over layer routes
+ * Layer routes are nested under the host's root layout if one exists
+ * If app has a layout route for a path, layer routes become its children
+ */
+declare function mergeRoutes(appRoutes: RouteNode[], layerRoutes: RouteNode[], _config?: ResolvedRouterConfig): RouteNode[];
+//#endregion
 //#region src/layout-resolver.d.ts
 /**
  * Resolved layout information
@@ -501,4 +510,113 @@ declare function generateLayoutStructure(chain: LayoutChain): {
   children?: any[];
 } | null;
 //#endregion
-export { type ExtendedParsedRoute, type GeneratedOutput, type KimeshRouterConfig, type KimeshRouterPluginOptions, type LayerRouteConfig, type LayerRouteNode, type LayerRouteSource, type LayerRoutesResult, type LayoutChain, LayoutResolver, type ParsedFileName, type ParsedRoute, type ResolvedLayout, type ResolvedRouterConfig, type RouteNode, type RouteNodeType, type RouteParam, RouteScanner, RouteTreeBuilder, type TreeNode, buildGlobPattern, buildRoutePath, buildRouteTree, collectLayerRoutes, createCatchAllParam, createDynamicParam, createEmptyParsedRoute, createScanner, createTreeBuilder, extractDynamicParam, generateLayoutStructure, generateRouteTypes, generateRoutes, isDotNotationRoute, isRootDir, kimeshRouterGenerator, parseRouteFile, processDirectoryPath, processPathSegment, unescapeBrackets };
+//#region src/middleware/types.d.ts
+/**
+ * @kimesh/router-generator - Middleware Types (Build-time)
+ */
+/**
+ * Middleware file metadata discovered during scanning
+ */
+interface MiddlewareFile {
+  /** Middleware name (without extension and .global suffix) */
+  name: string;
+  /** Original filename with extension */
+  fileName: string;
+  /** Absolute path to the middleware file */
+  filePath: string;
+  /** Whether this is a global middleware (`.global.ts` suffix) */
+  isGlobal: boolean;
+  /** Optional priority extracted from filename (e.g., `01.auth.global.ts` -> 1) */
+  priority?: number;
+  /** Source layer name (for multi-layer support) */
+  layer?: string;
+}
+/**
+ * Middleware scanning options
+ */
+interface MiddlewareScanOptions {
+  /** Root directory of the project */
+  root: string;
+  /** Middleware directory path (usually `src/middleware`) */
+  middlewareDir: string;
+  /** File extensions to scan */
+  extensions?: string[];
+  /** Ordering strategy for middleware */
+  orderStrategy?: "alphabetical" | "explicit" | "none";
+}
+/**
+ * Layer middleware configuration
+ */
+interface LayerMiddlewareConfig {
+  /** Layer name */
+  layerName: string;
+  /** Layer path */
+  layerPath: string;
+  /** Middleware directory within the layer */
+  middlewareDir: string;
+  /** Layer priority (lower = higher priority) */
+  priority: number;
+}
+/**
+ * Result of middleware scanning
+ */
+interface MiddlewareScanResult {
+  /** All discovered middleware files */
+  middleware: MiddlewareFile[];
+  /** Global middleware (sorted by priority/order) */
+  globalMiddleware: MiddlewareFile[];
+  /** Named middleware (non-global) */
+  namedMiddleware: MiddlewareFile[];
+}
+//#endregion
+//#region src/middleware/scanner.d.ts
+/**
+ * Scan a single middleware directory
+ */
+declare function scanMiddlewareDir(middlewareDir: string, options?: {
+  extensions?: string[];
+  layer?: string;
+}): Promise<MiddlewareFile[]>;
+/**
+ * Scan middleware files from the application
+ */
+declare function scanMiddlewareFiles(options: MiddlewareScanOptions): Promise<MiddlewareScanResult>;
+/**
+ * Scan middleware from multiple layers and merge them
+ * Layer priority determines override behavior (lower = higher priority)
+ */
+declare function scanLayerMiddleware(layers: LayerMiddlewareConfig[], options?: {
+  extensions?: string[];
+  orderStrategy?: "alphabetical" | "explicit" | "none";
+}): Promise<MiddlewareScanResult>;
+/**
+ * Create a middleware scanner with configuration
+ */
+declare class MiddlewareScanner {
+  private options;
+  constructor(options: MiddlewareScanOptions);
+  /**
+   * Scan the configured middleware directory
+   */
+  scan(): Promise<MiddlewareScanResult>;
+  /**
+   * Check if middleware directory exists
+   */
+  exists(): boolean;
+}
+//#endregion
+//#region src/middleware/codegen.d.ts
+/**
+ * Generate middleware registry code
+ */
+declare function generateMiddlewareRegistry(result: MiddlewareScanResult): string;
+/**
+ * Generate middleware type declarations
+ */
+declare function generateMiddlewareTypes(result: MiddlewareScanResult): string;
+/**
+ * Generate middleware module content for a specific middleware file
+ */
+declare function generateMiddlewareModule(file: MiddlewareFile): string;
+//#endregion
+export { type ExtendedParsedRoute, type GeneratedOutput, type KimeshRouterConfig, type KimeshRouterPluginOptions, type LayerMiddlewareConfig, type LayerRouteConfig, type LayerRouteNode, type LayerRouteSource, type LayerRoutesResult, type LayoutChain, LayoutResolver, type MiddlewareFile, type MiddlewareScanOptions, type MiddlewareScanResult, MiddlewareScanner, type ParsedFileName, type ParsedRoute, type ResolvedLayout, type ResolvedRouterConfig, type RouteNode, type RouteNodeType, type RouteParam, RouteScanner, RouteTreeBuilder, type TreeNode, buildGlobPattern, buildRoutePath, buildRouteTree, collectLayerRoutes, createCatchAllParam, createDynamicParam, createEmptyParsedRoute, createScanner, createTreeBuilder, extractDynamicParam, generateLayoutStructure, generateMiddlewareModule, generateMiddlewareRegistry, generateMiddlewareTypes, generateRouteTypes, generateRoutes, isDotNotationRoute, isRootDir, kimeshRouterGenerator, mergeRoutes, parseRouteFile, processDirectoryPath, processPathSegment, scanLayerMiddleware, scanMiddlewareDir, scanMiddlewareFiles, unescapeBrackets };

package/dist/index.mjs

@@ -1,11 +1,50 @@
 import * as path from "pathe";
+import { basename, extname, join } from "pathe";
 import * as fs from "node:fs";
+import { existsSync } from "node:fs";
 import { watch } from "chokidar";
 import fg from "fast-glob";
 import { parse } from "@vue/compiler-sfc";
 import { parseSync } from "oxc-parser";
 import { consola } from "consola";
+import { readdir } from "node:fs/promises";
 
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+//#endregion
 //#region src/parser.ts
 /**
 * @kimesh/router-generator - OXC-Powered Route Parser
@@ -1637,6 +1676,83 @@ function shouldBeLazy(filePath, config) {
 	return importMode === "async";
 }
 
+//#endregion
+//#region src/route-merger.ts
+var route_merger_exports = /* @__PURE__ */ __exportAll({ mergeRoutes: () => mergeRoutes });
+/**
+* Merge app routes with layer routes
+* App routes (priority 0) take precedence over layer routes
+* Layer routes are nested under the host's root layout if one exists
+* If app has a layout route for a path, layer routes become its children
+*/
+function mergeRoutes(appRoutes, layerRoutes, _config) {
+	const rootLayout = findRootLayout(appRoutes);
+	if (rootLayout && rootLayout.children) return mergeWithRootLayout(appRoutes, layerRoutes, rootLayout);
+	return mergeWithoutRootLayout(appRoutes, layerRoutes);
+}
+function findRootLayout(routes) {
+	return routes.find((r) => r.routePath === "/" && r.type === "layout") || null;
+}
+function mergeWithRootLayout(appRoutes, layerRoutes, rootLayout) {
+	const layoutRoutesByPath = buildLayoutRoutesMap(rootLayout.children);
+	for (const layerRoute of layerRoutes) {
+		const relativePath = normalizeRoutePath(layerRoute.routePath);
+		const hostLayoutRoute = layoutRoutesByPath.get(relativePath);
+		if (hostLayoutRoute) nestLayerUnderHost(layerRoute, hostLayoutRoute);
+		else addLayerAsSibling(layerRoute, relativePath, rootLayout, layoutRoutesByPath);
+	}
+	sortRouteChildren(rootLayout.children);
+	return appRoutes;
+}
+function buildLayoutRoutesMap(children) {
+	const map = /* @__PURE__ */ new Map();
+	for (const child of children) if (child.routePath && !child.routePath.includes(":")) {
+		const normalizedPath = normalizeRoutePath(child.routePath);
+		map.set(normalizedPath, child);
+	}
+	return map;
+}
+function normalizeRoutePath(routePath) {
+	return routePath.startsWith("/") ? routePath.slice(1) : routePath;
+}
+function nestLayerUnderHost(layerRoute, hostLayoutRoute) {
+	hostLayoutRoute.children = hostLayoutRoute.children || [];
+	hostLayoutRoute.type = "layout";
+	const layerWrapper = {
+		...layerRoute,
+		routePath: "",
+		parent: hostLayoutRoute
+	};
+	hostLayoutRoute.children.push(layerWrapper);
+}
+function addLayerAsSibling(layerRoute, relativePath, rootLayout, layoutRoutesByPath) {
+	const nestedRoute = {
+		...layerRoute,
+		routePath: relativePath,
+		parent: rootLayout
+	};
+	rootLayout.children.push(nestedRoute);
+	layoutRoutesByPath.set(relativePath, nestedRoute);
+}
+function sortRouteChildren(children) {
+	children.sort((a, b) => {
+		if (a.routePath === "") return -1;
+		if (b.routePath === "") return 1;
+		return a.routePath.localeCompare(b.routePath);
+	});
+}
+function mergeWithoutRootLayout(appRoutes, layerRoutes) {
+	const merged = [...appRoutes];
+	const usedPaths = new Set(appRoutes.map((r) => r.routePath));
+	for (const layerRoute of layerRoutes) if (!usedPaths.has(layerRoute.routePath)) {
+		merged.push(layerRoute);
+		usedPaths.add(layerRoute.routePath);
+	}
+	merged.sort((a, b) => a.routePath.localeCompare(b.routePath));
+	return merged;
+}
+var init_route_merger = __esmMin((() => {}));
+
 //#endregion
 //#region src/plugin.ts
 const VIRTUAL_ROUTES_ID = "\0virtual:kimesh-routes";
@@ -1743,7 +1859,7 @@ function kimeshRouterGenerator(options = {}) {
 					priority: l.priority
 				})), config);
 				log("Collected layer routes:", layerResult.routes.length);
-				routes = mergeRoutes(appRoutes, layerResult.routes, config);
+				routes = mergeRoutes$1(appRoutes, layerResult.routes, config);
 			} else routes = appRoutes;
 			log("Final merged routes:", routes.length, routes.map((r) => r.routePath));
 			await writeGeneratedFiles();
@@ -1799,75 +1915,14 @@ function kimeshRouterGenerator(options = {}) {
 * Layer routes are nested under the host's root layout if one exists
 * If app has a layout route for a path, layer routes become its children
 */
-function mergeRoutes(appRoutes, layerRoutes, _config) {
-	const rootLayout = findRootLayout(appRoutes);
-	if (rootLayout && rootLayout.children) return mergeWithRootLayout(appRoutes, layerRoutes, rootLayout);
-	return mergeWithoutRootLayout(appRoutes, layerRoutes);
-}
-function findRootLayout(routes) {
-	return routes.find((r) => r.routePath === "/" && r.type === "layout") || null;
-}
-function mergeWithRootLayout(appRoutes, layerRoutes, rootLayout) {
-	const layoutRoutesByPath = buildLayoutRoutesMap(rootLayout.children);
-	for (const layerRoute of layerRoutes) {
-		const relativePath = normalizeRoutePath(layerRoute.routePath);
-		const hostLayoutRoute = layoutRoutesByPath.get(relativePath);
-		if (hostLayoutRoute) nestLayerUnderHost(layerRoute, hostLayoutRoute);
-		else addLayerAsSibling(layerRoute, relativePath, rootLayout, layoutRoutesByPath);
-	}
-	sortRouteChildren(rootLayout.children);
-	return appRoutes;
-}
-function buildLayoutRoutesMap(children) {
-	const map = /* @__PURE__ */ new Map();
-	for (const child of children) if (child.routePath && !child.routePath.includes(":")) {
-		const normalizedPath = normalizeRoutePath(child.routePath);
-		map.set(normalizedPath, child);
-	}
-	return map;
-}
-function normalizeRoutePath(routePath) {
-	return routePath.startsWith("/") ? routePath.slice(1) : routePath;
-}
-function nestLayerUnderHost(layerRoute, hostLayoutRoute) {
-	hostLayoutRoute.children = hostLayoutRoute.children || [];
-	hostLayoutRoute.type = "layout";
-	const layerWrapper = {
-		...layerRoute,
-		routePath: "",
-		parent: hostLayoutRoute
-	};
-	hostLayoutRoute.children.push(layerWrapper);
-}
-function addLayerAsSibling(layerRoute, relativePath, rootLayout, layoutRoutesByPath) {
-	const nestedRoute = {
-		...layerRoute,
-		routePath: relativePath,
-		parent: rootLayout
-	};
-	rootLayout.children.push(nestedRoute);
-	layoutRoutesByPath.set(relativePath, nestedRoute);
-}
-function sortRouteChildren(children) {
-	children.sort((a, b) => {
-		if (a.routePath === "") return -1;
-		if (b.routePath === "") return 1;
-		return a.routePath.localeCompare(b.routePath);
-	});
-}
-function mergeWithoutRootLayout(appRoutes, layerRoutes) {
-	const merged = [...appRoutes];
-	const usedPaths = new Set(appRoutes.map((r) => r.routePath));
-	for (const layerRoute of layerRoutes) if (!usedPaths.has(layerRoute.routePath)) {
-		merged.push(layerRoute);
-		usedPaths.add(layerRoute.routePath);
-	}
-	merged.sort((a, b) => a.routePath.localeCompare(b.routePath));
-	return merged;
+function mergeRoutes$1(appRoutes, layerRoutes, _config) {
+	const { mergeRoutes: mergeRoutesImpl } = (init_route_merger(), __toCommonJS(route_merger_exports));
+	return mergeRoutesImpl(appRoutes, layerRoutes, _config);
 }
 
 //#endregion
 //#region src/layout-resolver.ts
+init_route_merger();
 /**
 * @kimesh/router-generator - Layout Resolver
 *
@@ -2025,4 +2080,283 @@ function generateLayoutStructure(chain) {
 }
 
 //#endregion
-export { LayoutResolver, RouteScanner, RouteTreeBuilder, buildGlobPattern, buildRoutePath, buildRouteTree, collectLayerRoutes, createCatchAllParam, createDynamicParam, createEmptyParsedRoute, createScanner, createTreeBuilder, extractDynamicParam, generateLayoutStructure, generateRouteTypes, generateRoutes, isDotNotationRoute, isRootDir, kimeshRouterGenerator, parseRouteFile, processDirectoryPath, processPathSegment, unescapeBrackets };
+//#region src/middleware/scanner.ts
+/**
+* @kimesh/router-generator - Middleware Scanner
+*
+* Scans middleware directories for middleware files following conventions:
+* - `*.ts` or `*.js` files in `src/middleware/`
+* - `.global.ts` suffix for global middleware
+* - Numeric prefix for priority (e.g., `01.auth.global.ts`)
+*/
+const DEFAULT_EXTENSIONS = [
+	".ts",
+	".js",
+	".mjs",
+	".cjs"
+];
+/**
+* Extract priority from filename
+* Supports format: "01.auth.global.ts" -> priority 1
+*/
+function extractPriority(name) {
+	const match = name.match(/^(\d+)\./);
+	return match ? parseInt(match[1], 10) : void 0;
+}
+/**
+* Parse middleware filename into metadata
+*/
+function parseMiddlewareFile(filePath, fileName, layer) {
+	const nameWithoutExt = basename(fileName, extname(fileName));
+	const isGlobal = nameWithoutExt.endsWith(".global");
+	const nameWithoutGlobal = isGlobal ? nameWithoutExt.slice(0, -7) : nameWithoutExt;
+	const priority = extractPriority(nameWithoutGlobal);
+	return {
+		name: priority !== void 0 ? nameWithoutGlobal.replace(/^\d+\./, "") : nameWithoutGlobal,
+		fileName,
+		filePath,
+		isGlobal,
+		priority,
+		layer
+	};
+}
+/**
+* Scan a single middleware directory
+*/
+async function scanMiddlewareDir(middlewareDir, options = {}) {
+	const extensions = options.extensions || DEFAULT_EXTENSIONS;
+	const middlewareFiles = [];
+	if (!existsSync(middlewareDir)) return [];
+	try {
+		const files = await readdir(middlewareDir, { withFileTypes: true });
+		for (const file of files) {
+			if (!file.isFile()) continue;
+			const ext = extname(file.name);
+			if (!extensions.includes(ext)) continue;
+			const parsed = parseMiddlewareFile(join(middlewareDir, file.name), file.name, options.layer);
+			middlewareFiles.push(parsed);
+		}
+	} catch (error) {
+		console.warn(`[Kimesh] Could not scan middleware directory: ${middlewareDir}`, error);
+	}
+	return middlewareFiles;
+}
+/**
+* Sort middleware files according to the specified strategy
+*/
+function sortMiddleware(files, strategy) {
+	if (strategy === "none") return files;
+	return [...files].sort((a, b) => {
+		if (a.isGlobal !== b.isGlobal) return a.isGlobal ? -1 : 1;
+		if (strategy === "explicit") {
+			const aPriority = a.priority ?? Infinity;
+			const bPriority = b.priority ?? Infinity;
+			if (aPriority !== bPriority) return aPriority - bPriority;
+		}
+		return a.name.localeCompare(b.name);
+	});
+}
+/**
+* Scan middleware files from the application
+*/
+async function scanMiddlewareFiles(options) {
+	const strategy = options.orderStrategy || "alphabetical";
+	const extensions = options.extensions || DEFAULT_EXTENSIONS;
+	const sorted = sortMiddleware(await scanMiddlewareDir(options.middlewareDir, { extensions }), strategy);
+	return {
+		middleware: sorted,
+		globalMiddleware: sorted.filter((m) => m.isGlobal),
+		namedMiddleware: sorted.filter((m) => !m.isGlobal)
+	};
+}
+/**
+* Scan middleware from multiple layers and merge them
+* Layer priority determines override behavior (lower = higher priority)
+*/
+async function scanLayerMiddleware(layers, options = {}) {
+	const strategy = options.orderStrategy || "alphabetical";
+	const extensions = options.extensions || DEFAULT_EXTENSIONS;
+	const allMiddleware = [];
+	const seenNames = /* @__PURE__ */ new Map();
+	const sortedLayers = [...layers].sort((a, b) => b.priority - a.priority);
+	for (const layer of sortedLayers) {
+		const files = await scanMiddlewareDir(layer.middlewareDir, {
+			extensions,
+			layer: layer.layerName
+		});
+		for (const file of files) {
+			const key = `${file.name}:${file.isGlobal}`;
+			seenNames.set(key, file);
+		}
+	}
+	allMiddleware.push(...seenNames.values());
+	const sorted = sortMiddleware(allMiddleware, strategy);
+	return {
+		middleware: sorted,
+		globalMiddleware: sorted.filter((m) => m.isGlobal),
+		namedMiddleware: sorted.filter((m) => !m.isGlobal)
+	};
+}
+/**
+* Create a middleware scanner with configuration
+*/
+var MiddlewareScanner = class {
+	options;
+	constructor(options) {
+		this.options = {
+			extensions: DEFAULT_EXTENSIONS,
+			orderStrategy: "alphabetical",
+			...options
+		};
+	}
+	/**
+	* Scan the configured middleware directory
+	*/
+	async scan() {
+		return scanMiddlewareFiles(this.options);
+	}
+	/**
+	* Check if middleware directory exists
+	*/
+	exists() {
+		return existsSync(this.options.middlewareDir);
+	}
+};
+
+//#endregion
+//#region src/middleware/codegen.ts
+/**
+* Generate a safe variable name from middleware name
+*/
+function toSafeVariableName(name) {
+	return name.replace(/[^a-zA-Z0-9_$]/g, "_");
+}
+/**
+* Normalize file path for import (forward slashes, no backslashes, no .ts extension)
+*/
+function normalizeImportPath(filePath) {
+	return filePath.replace(/\\/g, "/").replace(/\.ts$/, "");
+}
+/**
+* Generate middleware registry code
+*/
+function generateMiddlewareRegistry(result) {
+	const { globalMiddleware, namedMiddleware, middleware } = result;
+	if (middleware.length === 0) return generateEmptyRegistry();
+	const lines = [
+		"// Auto-generated by @kimesh/router-generator",
+		"// DO NOT EDIT - This file is regenerated when middleware files change",
+		""
+	];
+	if (globalMiddleware.length > 0) {
+		lines.push("// Global middleware imports (eager loading)");
+		for (const mw of globalMiddleware) {
+			const varName = `global_${toSafeVariableName(mw.name)}`;
+			lines.push(`import ${varName} from '${normalizeImportPath(mw.filePath)}';`);
+		}
+		lines.push("");
+	}
+	lines.push("// Global middleware (executed on every navigation)");
+	if (globalMiddleware.length > 0) {
+		const globalNames = globalMiddleware.map((mw) => `global_${toSafeVariableName(mw.name)}`);
+		lines.push(`export const globalMiddleware = [${globalNames.join(", ")}];`);
+	} else lines.push("export const globalMiddleware = [];");
+	lines.push("");
+	lines.push("// Named middleware (lazy loaded when needed)");
+	if (namedMiddleware.length > 0) {
+		const namedEntries = namedMiddleware.map((mw) => {
+			const importPath = normalizeImportPath(mw.filePath);
+			return `  '${mw.name}': () => import('${importPath}').then(m => m.default || m)`;
+		});
+		lines.push(`export const namedMiddleware = {`);
+		lines.push(namedEntries.join(",\n"));
+		lines.push("};");
+	} else lines.push("export const namedMiddleware = {};");
+	lines.push("");
+	const allNames = middleware.map((m) => `'${m.name}'`);
+	lines.push("// Middleware names (for type safety)");
+	lines.push(`export const middlewareNames = [${allNames.join(", ")}] as const;`);
+	lines.push("export type MiddlewareName = typeof middlewareNames[number];");
+	lines.push("");
+	lines.push("// Helper functions");
+	lines.push(`export function getGlobalMiddleware() {`);
+	lines.push(`  return globalMiddleware;`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`export function getNamedMiddleware(name: string) {`);
+	lines.push(`  return namedMiddleware[name as keyof typeof namedMiddleware];`);
+	lines.push(`}`);
+	lines.push("");
+	lines.push(`export function hasMiddleware(name: string): boolean {`);
+	lines.push(`  return middlewareNames.includes(name as MiddlewareName);`);
+	lines.push(`}`);
+	return lines.join("\n");
+}
+/**
+* Generate empty middleware registry
+*/
+function generateEmptyRegistry() {
+	return `// Auto-generated by @kimesh/router-generator
+// No middleware files found
+
+export const globalMiddleware = [];
+export const namedMiddleware = {};
+export const middlewareNames = [] as const;
+export type MiddlewareName = never;
+
+export function getGlobalMiddleware() {
+  return [];
+}
+
+export function getNamedMiddleware(_name: string) {
+  return undefined;
+}
+
+export function hasMiddleware(_name: string): boolean {
+  return false;
+}
+`;
+}
+/**
+* Generate middleware type declarations
+*/
+function generateMiddlewareTypes(result) {
+	const { middleware } = result;
+	const lines = [
+		"// Auto-generated middleware type declarations",
+		"// DO NOT EDIT - This file is regenerated when middleware files change",
+		"",
+		"import type { RouteMiddleware } from \"@kimesh/router-runtime\";",
+		""
+	];
+	if (middleware.length > 0) {
+		const names = middleware.map((m) => `'${m.name}'`).join(" | ");
+		lines.push(`export type KnownMiddleware = ${names};`);
+	} else lines.push("export type KnownMiddleware = never;");
+	lines.push("");
+	lines.push("declare module \"vue-router\" {");
+	lines.push("  interface RouteMeta {");
+	lines.push("    middleware?: KnownMiddleware | KnownMiddleware[] | RouteMiddleware | RouteMiddleware[];");
+	lines.push("  }");
+	lines.push("}");
+	lines.push("");
+	lines.push("declare module \"@kimesh/router-runtime\" {");
+	lines.push("  interface KimeshMiddlewareNames {");
+	for (const mw of middleware) lines.push(`    '${mw.name}': true;`);
+	lines.push("  }");
+	lines.push("}");
+	return lines.join("\n");
+}
+/**
+* Generate middleware module content for a specific middleware file
+*/
+function generateMiddlewareModule(file) {
+	return `// Middleware: ${file.name}
+// Auto-generated export wrapper
+
+export { default } from '${normalizeImportPath(file.filePath)}';
+`;
+}
+
+//#endregion
+export { LayoutResolver, MiddlewareScanner, RouteScanner, RouteTreeBuilder, buildGlobPattern, buildRoutePath, buildRouteTree, collectLayerRoutes, createCatchAllParam, createDynamicParam, createEmptyParsedRoute, createScanner, createTreeBuilder, extractDynamicParam, generateLayoutStructure, generateMiddlewareModule, generateMiddlewareRegistry, generateMiddlewareTypes, generateRouteTypes, generateRoutes, isDotNotationRoute, isRootDir, kimeshRouterGenerator, mergeRoutes, parseRouteFile, processDirectoryPath, processPathSegment, scanLayerMiddleware, scanMiddlewareDir, scanMiddlewareFiles, unescapeBrackets };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kimesh/router-generator",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "File-based route generator for Kimesh",
   "type": "module",
   "repository": {