@h3ravel/router 1.8.3 → 1.9.0

package/dist/index.js

@@ -1,388 +1,428 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/Providers/AssetsServiceProvider.ts
-import { readFile, stat } from "fs/promises";
-import { ServiceProvider } from "@h3ravel/core";
-import { before } from "@h3ravel/support";
-import { join } from "path";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { Container, Kernel, ServiceProvider } from "@h3ravel/core";
+import { before, singularize } from "@h3ravel/support";
+import path, { join } from "node:path";
 import { serveStatic } from "h3";
-import { statSync } from "fs";
-var AssetsServiceProvider = class extends ServiceProvider {
-  static {
-    __name(this, "AssetsServiceProvider");
-  }
-  static priority = 996;
-  register() {
-    const app = this.app.make("router");
-    const config = this.app.make("config");
-    const fsconfig = config.get("filesystem");
-    const publicPath = this.app.getPath("public");
-    app.middleware(`/${fsconfig.public_mask}/**`, (event) => {
-      return serveStatic(event, {
-        indexNames: [
-          "/index.html"
-        ],
-        getContents: /* @__PURE__ */ __name((id) => {
-          const newId = id.replace(`/${fsconfig.public_mask}/`, "");
-          return readFile(join(before(publicPath, newId), newId));
-        }, "getContents"),
-        getMeta: /* @__PURE__ */ __name(async (id) => {
-          const newId = id.replace(`/${fsconfig.public_mask}/`, "");
-          const stats = await stat(join(before(publicPath, newId), newId)).catch(() => {
-          });
-          if (stats?.isFile()) {
-            return {
-              size: stats.size,
-              mtime: stats.mtimeMs
-            };
-          }
-        }, "getMeta")
-      });
-    });
-    this.app.singleton("asset", () => {
-      return (key, def = "") => {
-        try {
-          statSync(join(before(publicPath, key), key));
-        } catch {
-          key = def;
-        }
-        return join(fsconfig.public_mask, key);
-      };
-    });
-  }
-};
-
-// src/Route.ts
+import { statSync } from "node:fs";
 import "reflect-metadata";
-import { Container, Kernel } from "@h3ravel/core";
 import { Request, Response } from "@h3ravel/http";
-import { singularize } from "@h3ravel/support";
 import { HttpContext } from "@h3ravel/shared";
-var Router = class {
-  static {
-    __name(this, "Router");
-  }
-  h3App;
-  app;
-  routes = [];
-  nameMap = [];
-  groupPrefix = "";
-  middlewareMap = [];
-  groupMiddleware = [];
-  constructor(h3App, app) {
-    this.h3App = h3App;
-    this.app = app;
-  }
-  /**
-   * Route Resolver
-   * 
-   * @param handler 
-   * @param middleware 
-   * @returns 
-   */
-  resolveHandler(handler, middleware = []) {
-    return async (event) => {
-      const kernel = new Kernel(() => HttpContext.init({
-        app: this.app,
-        request: new Request(event, this.app),
-        response: new Response(event, this.app)
-      }), middleware);
-      return kernel.handle(event, (ctx) => Promise.resolve(handler(ctx)));
-    };
-  }
-  /**
-   * Add a route to the stack
-   * 
-   * @param method 
-   * @param path 
-   * @param handler 
-   * @param name 
-   * @param middleware 
-   */
-  addRoute(method, path2, handler, name, middleware = []) {
-    if (this.nameMap.length > 0) {
-      name = this.nameMap.join(".");
-    }
-    if (this.middlewareMap.length > 0) {
-      middleware = this.middlewareMap;
-    }
-    const fullPath = `${this.groupPrefix}${path2}`.replace(/\/+/g, "/");
-    this.routes.push({
-      method,
-      path: fullPath,
-      name,
-      handler
-    });
-    this.h3App[method](fullPath, this.resolveHandler(handler, middleware));
-  }
-  /**
-   * Resolves a route handler definition into an executable EventHandler.
-   *
-   * A handler can be:
-   *   - A function matching the EventHandler signature
-   *   - A controller class (optionally decorated for IoC resolution)
-   *
-   * If it’s a controller class, this method will:
-   *   - Instantiate it (via IoC or manually)
-   *   - Call the specified method (defaults to `index`)
-   *
-   * @param handler     Event handler function OR controller class
-   * @param methodName  Method to invoke on the controller (defaults to 'index')
-   */
-  resolveControllerOrHandler(handler, methodName) {
-    if (typeof handler === "function" && typeof handler.prototype !== "undefined") {
-      return (_ctx) => {
-        let controller;
-        if (Container.hasAnyDecorator(handler)) {
-          controller = this.app.make(handler);
-        } else {
-          controller = new handler(this.app);
-        }
-        const action = methodName || "index";
-        if (typeof controller[action] !== "function") {
-          throw new Error(`Method "${String(action)}" not found on controller ${handler.name}`);
-        }
-        const paramTypes = Reflect.getMetadata("design:paramtypes", controller, action) || [];
-        let args = paramTypes.map((paramType) => {
-          switch (paramType?.name) {
-            case "Application":
-              return this.app;
-            case "Request":
-              return _ctx.request;
-            case "Response":
-              return _ctx.response;
-            case "HttpContext":
-              return _ctx;
-            default:
-              return this.app.make(paramType);
-          }
-        });
-        if (args.length < 1) {
-          args = [
-            _ctx
-          ];
-        }
-        return controller[action](...args);
-      };
-    }
-    return handler;
-  }
-  /**
-   * Registers a route that responds to HTTP GET requests.
-   *
-   * @param path        The URL pattern to match (can include parameters, e.g., '/users/:id').
-   * @param definition  Either:
-   *                      - An EventHandler function
-   *                      - A tuple: [ControllerClass, methodName]
-   * @param name        Optional route name (for URL generation or referencing).
-   * @param middleware  Optional array of middleware functions to execute before the handler.
-   */
-  get(path2, definition, name, middleware = []) {
-    const handler = Array.isArray(definition) ? definition[0] : definition;
-    const methodName = Array.isArray(definition) ? definition[1] : void 0;
-    this.addRoute("get", path2, this.resolveControllerOrHandler(handler, methodName), name, middleware);
-    return this;
-  }
-  /**
-   * Registers a route that responds to HTTP POST requests.
-   *
-   * @param path        The URL pattern to match (can include parameters, e.g., '/users').
-   * @param definition  Either:
-   *                      - An EventHandler function
-   *                      - A tuple: [ControllerClass, methodName]
-   * @param name        Optional route name (for URL generation or referencing).
-   * @param middleware  Optional array of middleware functions to execute before the handler.
-   */
-  post(path2, definition, name, middleware = []) {
-    const handler = Array.isArray(definition) ? definition[0] : definition;
-    const methodName = Array.isArray(definition) ? definition[1] : void 0;
-    this.addRoute("post", path2, this.resolveControllerOrHandler(handler, methodName), name, middleware);
-    return this;
-  }
-  /**
-   * Registers a route that responds to HTTP PUT requests.
-   *
-   * @param path        The URL pattern to match (can include parameters, e.g., '/users/:id').
-   * @param definition  Either:
-   *                      - An EventHandler function
-   *                      - A tuple: [ControllerClass, methodName]
-   * @param name        Optional route name (for URL generation or referencing).
-   * @param middleware  Optional array of middleware functions to execute before the handler.
-   */
-  put(path2, definition, name, middleware = []) {
-    const handler = Array.isArray(definition) ? definition[0] : definition;
-    const methodName = Array.isArray(definition) ? definition[1] : void 0;
-    this.addRoute("put", path2, this.resolveControllerOrHandler(handler, methodName), name, middleware);
-    return this;
-  }
-  /**
-   * Registers a route that responds to HTTP PATCH requests.
-   *
-   * @param path        The URL pattern to match (can include parameters, e.g., '/users/:id').
-   * @param definition  Either:
-   *                      - An EventHandler function
-   *                      - A tuple: [ControllerClass, methodName]
-   * @param name        Optional route name (for URL generation or referencing).
-   * @param middleware  Optional array of middleware functions to execute before the handler.
-   */
-  patch(path2, definition, name, middleware = []) {
-    const handler = Array.isArray(definition) ? definition[0] : definition;
-    const methodName = Array.isArray(definition) ? definition[1] : void 0;
-    this.addRoute("patch", path2, this.resolveControllerOrHandler(handler, methodName), name, middleware);
-    return this;
-  }
-  /**
-   * Registers a route that responds to HTTP DELETE requests.
-   *
-   * @param path        The URL pattern to match (can include parameters, e.g., '/users/:id').
-   * @param definition  Either:
-   *                      - An EventHandler function
-   *                      - A tuple: [ControllerClass, methodName]
-   * @param name        Optional route name (for URL generation or referencing).
-   * @param middleware  Optional array of middleware functions to execute before the handler.
-   */
-  delete(path2, definition, name, middleware = []) {
-    const handler = Array.isArray(definition) ? definition[0] : definition;
-    const methodName = Array.isArray(definition) ? definition[1] : void 0;
-    this.addRoute("delete", path2, this.resolveControllerOrHandler(handler, methodName), name, middleware);
-    return this;
-  }
-  /**
-   * API Resource support  
-   * 
-   * @param path 
-   * @param controller 
-   */
-  apiResource(path2, Controller, middleware = []) {
-    path2 = path2.replace(/\//g, "/");
-    const basePath = `/${path2}`.replace(/\/+$/, "").replace(/(\/)+/g, "$1");
-    const name = basePath.substring(basePath.lastIndexOf("/") + 1).replaceAll(/\/|:/g, "") || "";
-    const param = singularize(name);
-    this.get(basePath, [
-      Controller,
-      "index"
-    ], `${name}.index`, middleware);
-    this.post(basePath, [
-      Controller,
-      "store"
-    ], `${name}.store`, middleware);
-    this.get(`${basePath}/:${param}`, [
-      Controller,
-      "show"
-    ], `${name}.show`, middleware);
-    this.put(`${basePath}/:${param}`, [
-      Controller,
-      "update"
-    ], `${name}.update`, middleware);
-    this.patch(`${basePath}/:${param}`, [
-      Controller,
-      "update"
-    ], `${name}.update`, middleware);
-    this.delete(`${basePath}/:${param}`, [
-      Controller,
-      "destroy"
-    ], `${name}.destroy`, middleware);
-    return this;
-  }
-  /**
-   * Named route URL generator
-   * 
-   * @param name 
-   * @param params 
-   * @returns 
-   */
-  route(name, params = {}) {
-    const found = this.routes.find((r) => r.name === name);
-    if (!found) return void 0;
-    let url = found.path;
-    for (const [key, value] of Object.entries(params)) {
-      url = url.replace(`:${key}`, value);
-    }
-    return url;
-  }
-  /**
-   * Grouping
-   * 
-   * @param options 
-   * @param callback 
-   */
-  group(options, callback) {
-    const prevPrefix = this.groupPrefix;
-    const prevMiddleware = [
-      ...this.groupMiddleware
-    ];
-    this.groupPrefix += options.prefix || "";
-    this.groupMiddleware.push(...options.middleware || []);
-    callback(this);
-    this.groupPrefix = prevPrefix;
-    this.groupMiddleware = prevMiddleware;
-    return this;
-  }
-  /**
-   * Set the name of the current route
-   * 
-   * @param name 
-   */
-  name(name) {
-    this.nameMap.push(name);
-    return this;
-  }
-  /**
-   * Registers middleware for a specific path.
-   * @param path - The path to apply the middleware.
-   * @param handler - The middleware handler.
-   * @param opts - Optional middleware options.
-   */
-  middleware(path2, handler, opts) {
-    if (typeof path2 === "string") {
-      this.h3App.use(path2, handler, opts);
-    } else {
-      this.middlewareMap.concat(path2);
-    }
-    return this;
-  }
+import { Model } from "@h3ravel/database";
+
+//#region src/Helpers.ts
+var Helpers = class Helpers {
+	/**
+	* Extracts parameter names from a route path string.
+	*
+	* - Looks for segments prefixed with ":" (e.g. "/users/:id")
+	* - Captures only the param name (without the ":")
+	* - Returns all matches in order of appearance
+	*
+	* @param path - The route path string (e.g. "/groups/:group/users/:user")
+	* @returns An array of parameter names (e.g. ["group", "user"])
+	*/
+	static extractParams(path$1) {
+		const regex = /:([^/]+)/g;
+		const params = [];
+		let match;
+		while ((match = regex.exec(path$1)) !== null) params.push(match[1]);
+		return params;
+	}
+	/**
+	* Resolves route model binding for a given path, HTTP context, and model.
+	* 
+	* - Extracts all route parameters from the given path
+	* - If a parameter matches the model name, it attempts to resolve the model binding
+	*   using the provided value and binding field (defaults to "id" unless specified).
+	* - For non-matching parameters, it simply returns the key-value pair as is.
+	* - If no parameters are found, returns an empty object.
+	*
+	* @param path - The route path (e.g. "/groups/:group/users/:user")
+	* @param ctx - The HTTP context containing the request
+	* @param model - The model instance to resolve bindings against
+	* @returns A resolved model instance or an object containing param values
+	*/
+	static async resolveRouteModelBinding(path$1, ctx, model) {
+		const name = model.constructor.name.toLowerCase();
+		/**
+		* Extract field (defaults to 'id' if not specified after '|')
+		*/
+		const field = name.split("|").at(1) ?? "id";
+		/**
+		* Iterate through extracted parameters from the path
+		*/
+		for await (const e of Helpers.extractParams(path$1)) {
+			const value = ctx.request.params[e] ?? null;
+			if (e === name) return await model.resolveRouteBinding(value, field);
+			else return { [e]: ctx.request.params[e] ?? {} };
+		}
+		return {};
+	}
 };
 
-// src/Providers/RouteServiceProvider.ts
-import { ServiceProvider as ServiceProvider2 } from "@h3ravel/core";
-import path from "path";
-import { readdir } from "fs/promises";
-var RouteServiceProvider = class extends ServiceProvider2 {
-  static {
-    __name(this, "RouteServiceProvider");
-  }
-  static priority = 997;
-  register() {
-    this.app.singleton("router", () => {
-      const h3App = this.app.make("http.app");
-      return new Router(h3App, this.app);
-    });
-  }
-  /**
-   * Load routes from src/routes
-   */
-  async boot() {
-    try {
-      const routePath = this.app.getPath("routes");
-      const files = (await readdir(routePath)).filter((e) => {
-        return !e.includes(".d.ts") && !e.includes(".map");
-      });
-      for (let i = 0; i < files.length; i++) {
-        const routesModule = await import(path.join(routePath, files[i]));
-        if (typeof routesModule.default === "function") {
-          const router = this.app.make("router");
-          routesModule.default(router);
-        }
-      }
-    } catch (e) {
-      console.warn("No web routes found or failed to load:", e);
-    }
-  }
+//#endregion
+//#region src/Providers/AssetsServiceProvider.ts
+/**
+* Handles public assets loading
+* 
+* Auto-Registered
+*/
+var AssetsServiceProvider = class extends ServiceProvider {
+	static priority = 996;
+	register() {
+		const app = this.app.make("router");
+		const fsconfig = this.app.make("config").get("filesystem");
+		const publicPath = this.app.getPath("public");
+		app.middleware(`/${fsconfig.public_mask}/**`, (event) => {
+			return serveStatic(event, {
+				indexNames: ["/index.html"],
+				getContents: (id) => {
+					const newId = id.replace(`/${fsconfig.public_mask}/`, "");
+					return readFile(join(before(publicPath, newId), newId));
+				},
+				getMeta: async (id) => {
+					const newId = id.replace(`/${fsconfig.public_mask}/`, "");
+					const stats = await stat(join(before(publicPath, newId), newId)).catch(() => {});
+					if (stats?.isFile()) return {
+						size: stats.size,
+						mtime: stats.mtimeMs
+					};
+				}
+			});
+		});
+		this.app.singleton("asset", () => {
+			return (key, def = "") => {
+				try {
+					statSync(join(before(publicPath, key), key));
+				} catch {
+					key = def;
+				}
+				return join(fsconfig.public_mask, key);
+			};
+		});
+	}
+};
+
+//#endregion
+//#region src/Route.ts
+var Router = class {
+	routes = [];
+	nameMap = [];
+	groupPrefix = "";
+	middlewareMap = [];
+	groupMiddleware = [];
+	constructor(h3App, app) {
+		this.h3App = h3App;
+		this.app = app;
+	}
+	/**
+	* Route Resolver
+	* 
+	* @param handler 
+	* @param middleware 
+	* @returns 
+	*/
+	resolveHandler(handler, middleware = []) {
+		return async (event) => {
+			return new Kernel(() => HttpContext.init({
+				app: this.app,
+				request: new Request(event, this.app),
+				response: new Response(event, this.app)
+			}), middleware).handle(event, (ctx) => Promise.resolve(handler(ctx)));
+		};
+	}
+	/**
+	* Add a route to the stack
+	* 
+	* @param method 
+	* @param path 
+	* @param handler 
+	* @param name 
+	* @param middleware 
+	*/
+	addRoute(method, path$1, handler, name, middleware = []) {
+		/**
+		* Join all defined route names to make a single route name
+		*/
+		if (this.nameMap.length > 0) name = this.nameMap.join(".");
+		/**
+		* Join all defined middlewares
+		*/
+		if (this.middlewareMap.length > 0) middleware = this.middlewareMap;
+		const fullPath = `${this.groupPrefix}${path$1}`.replace(/\/+/g, "/");
+		this.routes.push({
+			method,
+			path: fullPath,
+			name,
+			handler
+		});
+		this.h3App[method](fullPath, this.resolveHandler(handler, middleware));
+	}
+	/**
+	* Resolves a route handler definition into an executable EventHandler.
+	*
+	* A handler can be:
+	*   - A function matching the EventHandler signature
+	*   - A controller class (optionally decorated for IoC resolution)
+	*
+	* If it’s a controller class, this method will:
+	*   - Instantiate it (via IoC or manually)
+	*   - Call the specified method (defaults to `index`)
+	*
+	* @param handler     Event handler function OR controller class
+	* @param methodName  Method to invoke on the controller (defaults to 'index')
+	*/
+	resolveControllerOrHandler(handler, methodName, path$1) {
+		/**
+		* Checks if the handler is a function (either a plain function or a class constructor)
+		*/
+		if (typeof handler === "function" && typeof handler.prototype !== "undefined") return async (ctx) => {
+			let controller;
+			if (Container.hasAnyDecorator(handler))
+ /**
+			* If the controller is decorated use the IoC container
+			*/
+			controller = this.app.make(handler);
+			else
+ /**
+			* Otherwise instantiate manually so that we can at least
+			* pass the app instance
+			*/
+			controller = new handler(this.app);
+			/**
+			* The method to execute (defaults to 'index')
+			*/
+			const action = methodName || "index";
+			/**
+			* Ensure the method exists on the controller
+			*/
+			if (typeof controller[action] !== "function") throw new Error(`Method "${String(action)}" not found on controller ${handler.name}`);
+			/**
+			* Get param types for the controller method
+			*/
+			const paramTypes = Reflect.getMetadata("design:paramtypes", controller, action) || [];
+			/**
+			* Resolve the bound dependencies
+			*/
+			let args = await Promise.all(paramTypes.map(async (paramType) => {
+				switch (paramType?.name) {
+					case "Application": return this.app;
+					case "Request": return ctx.request;
+					case "Response": return ctx.response;
+					case "HttpContext": return ctx;
+					default: {
+						const inst = this.app.make(paramType);
+						if (inst instanceof Model) return await Helpers.resolveRouteModelBinding(path$1 ?? "", ctx, inst);
+						return inst;
+					}
+				}
+			}));
+			/**
+			* Ensure that the HttpContext is always available
+			*/
+			if (args.length < 1) args = [ctx];
+			/**
+			* Call the controller method, passing all resolved dependencies
+			*/
+			return await controller[action](...args);
+		};
+		return handler;
+	}
+	/**
+	* Registers a route that responds to HTTP GET requests.
+	*
+	* @param path        The URL pattern to match (can include parameters, e.g., '/users/:id').
+	* @param definition  Either:
+	*                      - An EventHandler function
+	*                      - A tuple: [ControllerClass, methodName]
+	* @param name        Optional route name (for URL generation or referencing).
+	* @param middleware  Optional array of middleware functions to execute before the handler.
+	*/
+	get(path$1, definition, name, middleware = []) {
+		const handler = Array.isArray(definition) ? definition[0] : definition;
+		const methodName = Array.isArray(definition) ? definition[1] : void 0;
+		this.addRoute("get", path$1, this.resolveControllerOrHandler(handler, methodName, path$1), name, middleware);
+		return this;
+	}
+	/**
+	* Registers a route that responds to HTTP POST requests.
+	*
+	* @param path        The URL pattern to match (can include parameters, e.g., '/users').
+	* @param definition  Either:
+	*                      - An EventHandler function
+	*                      - A tuple: [ControllerClass, methodName]
+	* @param name        Optional route name (for URL generation or referencing).
+	* @param middleware  Optional array of middleware functions to execute before the handler.
+	*/
+	post(path$1, definition, name, middleware = []) {
+		const handler = Array.isArray(definition) ? definition[0] : definition;
+		const methodName = Array.isArray(definition) ? definition[1] : void 0;
+		this.addRoute("post", path$1, this.resolveControllerOrHandler(handler, methodName, path$1), name, middleware);
+		return this;
+	}
+	/**
+	* Registers a route that responds to HTTP PUT requests.
+	*
+	* @param path        The URL pattern to match (can include parameters, e.g., '/users/:id').
+	* @param definition  Either:
+	*                      - An EventHandler function
+	*                      - A tuple: [ControllerClass, methodName]
+	* @param name        Optional route name (for URL generation or referencing).
+	* @param middleware  Optional array of middleware functions to execute before the handler.
+	*/
+	put(path$1, definition, name, middleware = []) {
+		const handler = Array.isArray(definition) ? definition[0] : definition;
+		const methodName = Array.isArray(definition) ? definition[1] : void 0;
+		this.addRoute("put", path$1, this.resolveControllerOrHandler(handler, methodName, path$1), name, middleware);
+		return this;
+	}
+	/**
+	* Registers a route that responds to HTTP PATCH requests.
+	*
+	* @param path        The URL pattern to match (can include parameters, e.g., '/users/:id').
+	* @param definition  Either:
+	*                      - An EventHandler function
+	*                      - A tuple: [ControllerClass, methodName]
+	* @param name        Optional route name (for URL generation or referencing).
+	* @param middleware  Optional array of middleware functions to execute before the handler.
+	*/
+	patch(path$1, definition, name, middleware = []) {
+		const handler = Array.isArray(definition) ? definition[0] : definition;
+		const methodName = Array.isArray(definition) ? definition[1] : void 0;
+		this.addRoute("patch", path$1, this.resolveControllerOrHandler(handler, methodName, path$1), name, middleware);
+		return this;
+	}
+	/**
+	* Registers a route that responds to HTTP DELETE requests.
+	*
+	* @param path        The URL pattern to match (can include parameters, e.g., '/users/:id').
+	* @param definition  Either:
+	*                      - An EventHandler function
+	*                      - A tuple: [ControllerClass, methodName]
+	* @param name        Optional route name (for URL generation or referencing).
+	* @param middleware  Optional array of middleware functions to execute before the handler.
+	*/
+	delete(path$1, definition, name, middleware = []) {
+		const handler = Array.isArray(definition) ? definition[0] : definition;
+		const methodName = Array.isArray(definition) ? definition[1] : void 0;
+		this.addRoute("delete", path$1, this.resolveControllerOrHandler(handler, methodName, path$1), name, middleware);
+		return this;
+	}
+	/**
+	* API Resource support  
+	* 
+	* @param path 
+	* @param controller 
+	*/
+	apiResource(path$1, Controller, middleware = []) {
+		path$1 = path$1.replace(/\//g, "/");
+		const basePath = `/${path$1}`.replace(/\/+$/, "").replace(/(\/)+/g, "$1");
+		const name = basePath.substring(basePath.lastIndexOf("/") + 1).replaceAll(/\/|:/g, "") || "";
+		const param = singularize(name);
+		this.get(basePath, [Controller, "index"], `${name}.index`, middleware);
+		this.post(basePath, [Controller, "store"], `${name}.store`, middleware);
+		this.get(`${basePath}/:${param}`, [Controller, "show"], `${name}.show`, middleware);
+		this.put(`${basePath}/:${param}`, [Controller, "update"], `${name}.update`, middleware);
+		this.patch(`${basePath}/:${param}`, [Controller, "update"], `${name}.update`, middleware);
+		this.delete(`${basePath}/:${param}`, [Controller, "destroy"], `${name}.destroy`, middleware);
+		return this;
+	}
+	/**
+	* Named route URL generator
+	* 
+	* @param name 
+	* @param params 
+	* @returns 
+	*/
+	route(name, params = {}) {
+		const found = this.routes.find((r) => r.name === name);
+		if (!found) return void 0;
+		let url = found.path;
+		for (const [key, value] of Object.entries(params)) url = url.replace(`:${key}`, value);
+		return url;
+	}
+	/**
+	* Grouping
+	* 
+	* @param options 
+	* @param callback 
+	*/
+	group(options, callback) {
+		const prevPrefix = this.groupPrefix;
+		const prevMiddleware = [...this.groupMiddleware];
+		this.groupPrefix += options.prefix || "";
+		this.groupMiddleware.push(...options.middleware || []);
+		callback(this);
+		/**
+		* Restore state after group
+		*/
+		this.groupPrefix = prevPrefix;
+		this.groupMiddleware = prevMiddleware;
+		return this;
+	}
+	/**
+	* Set the name of the current route
+	* 
+	* @param name 
+	*/
+	name(name) {
+		this.nameMap.push(name);
+		return this;
+	}
+	/**
+	* Registers middleware for a specific path.
+	* @param path - The path to apply the middleware.
+	* @param handler - The middleware handler.
+	* @param opts - Optional middleware options.
+	*/
+	middleware(path$1, handler, opts) {
+		if (typeof path$1 === "string") this.h3App.use(path$1, handler, opts);
+		else this.middlewareMap.concat(path$1);
+		return this;
+	}
 };
-export {
-  AssetsServiceProvider,
-  RouteServiceProvider,
-  Router
+
+//#endregion
+//#region src/Providers/RouteServiceProvider.ts
+/**
+* Handles routing registration
+* 
+* Load route files (web.ts, api.ts).
+* Map controllers to routes.
+* Register route-related middleware.
+* 
+* Auto-Registered
+*/
+var RouteServiceProvider = class extends ServiceProvider {
+	static priority = 997;
+	register() {
+		this.app.singleton("router", () => {
+			const h3App = this.app.make("http.app");
+			return new Router(h3App, this.app);
+		});
+	}
+	/**
+	* Load routes from src/routes
+	*/
+	async boot() {
+		try {
+			const routePath = this.app.getPath("routes");
+			const files = (await readdir(routePath)).filter((e) => {
+				return !e.includes(".d.ts") && !e.includes(".d.cts") && !e.includes(".map");
+			});
+			for (let i = 0; i < files.length; i++) {
+				const routesModule = await import(path.join(routePath, files[i]));
+				if (typeof routesModule.default === "function") {
+					const router = this.app.make("router");
+					routesModule.default(router);
+				}
+			}
+		} catch (e) {
+			console.warn("No web routes found or failed to load:", e);
+		}
+	}
 };
+
+//#endregion
+export { AssetsServiceProvider, Helpers, RouteServiceProvider, Router };
 //# sourceMappingURL=index.js.map