@rhythmjs/router 0.0.4 → 0.0.6

package/dist/radix-tree.d.ts

@@ -5,6 +5,7 @@ export declare class TreeNode<TMethod extends string = string, TPayload = unknow
   children: TreeNode<TMethod, TPayload>[];
   paramChild: TreeNode<TMethod, TPayload> | null;
   paramName: string;
+  wildcardChild: TreeNode<TMethod, TPayload> | null;
   methods: Map<TMethod, TPayload> | null;
 }
 export declare function createNode<TMethod extends string = string, TPayload = unknown>(): TreeNode<TMethod, TPayload>;

package/dist/radix-tree.js

@@ -5,6 +5,7 @@ var TreeNode = class {
 	children = [];
 	paramChild = null;
 	paramName = "";
+	wildcardChild = null;
 	methods = null;
 };
 function createNode() {
@@ -23,12 +24,14 @@ function splitChild(node, at) {
 	tail.children = node.children;
 	tail.paramChild = node.paramChild;
 	tail.paramName = node.paramName;
+	tail.wildcardChild = node.wildcardChild;
 	tail.methods = node.methods;
 	node.path = node.path.slice(0, at);
 	node.children = [tail];
 	node.indices = tail.path.charAt(0);
 	node.paramChild = null;
 	node.paramName = "";
+	node.wildcardChild = null;
 	node.methods = null;
 }
 function insertAt(node, path, method, payload) {
@@ -48,8 +51,19 @@ function insertAt(node, path, method, payload) {
 		insertAt(node.paramChild, rest, method, payload);
 		return;
 	}
+	if (path.charCodeAt(0) === 42) {
+		if (path.length !== 1) throw new Error("wildcard \"*\" is only allowed at the end of a path");
+		if (!node.wildcardChild) node.wildcardChild = new TreeNode();
+		if (!node.wildcardChild.methods) node.wildcardChild.methods = /* @__PURE__ */ new Map();
+		node.wildcardChild.methods.set(method, payload);
+		return;
+	}
 	const colonIndex = path.indexOf(":");
-	const staticPart = colonIndex === -1 ? path : path.slice(0, colonIndex);
+	const starIndex = path.indexOf("*");
+	let staticEnd = path.length;
+	if (colonIndex !== -1) staticEnd = colonIndex;
+	if (starIndex !== -1 && starIndex < staticEnd) staticEnd = starIndex;
+	const staticPart = path.slice(0, staticEnd);
 	const firstChar = path.charAt(0);
 	for (let i = 0; i < node.children.length; i++) {
 		if (node.indices.charAt(i) !== firstChar) continue;
@@ -66,47 +80,67 @@ function insertAt(node, path, method, payload) {
 	node.indices += firstChar;
 	insertAt(child, path.slice(staticPart.length), method, payload);
 }
+function expandOptionalParams(path) {
+	if (!path.includes("?")) return [path];
+	const segments = path.split("/");
+	let firstOptional = -1;
+	for (let i = 0; i < segments.length; i++) {
+		const segment = segments[i];
+		const isOptional = segment.length > 2 && segment.charCodeAt(0) === 58 && segment.endsWith("?");
+		if (!isOptional && segment.includes("?")) throw new Error(`"?" is only allowed to mark an optional param like ":name?" (in "${path}")`);
+		if (firstOptional !== -1 && !isOptional) throw new Error(`only optional params may follow an optional param (in "${path}")`);
+		if (isOptional && firstOptional === -1) firstOptional = i;
+	}
+	const variants = [];
+	for (let end = firstOptional; end <= segments.length; end++) {
+		const parts = segments.slice(0, end).map((segment) => segment.endsWith("?") ? segment.slice(0, -1) : segment);
+		variants.push(parts.join("/") || "/");
+	}
+	return variants;
+}
 function insertRoute(root, method, path, payload) {
-	insertAt(root, path, method, payload);
+	for (const variant of expandOptionalParams(path)) insertAt(root, variant, method, payload);
 }
-function lookupRoute(root, method, pathname) {
-	const params = {};
-	let node = root;
-	let path = pathname;
-	while (path.length > 0) {
+function search(node, method, path) {
+	if (path.length === 0) {
+		const payload = node.methods?.get(method);
+		if (payload !== void 0) return {
+			payload,
+			params: {}
+		};
+	} else {
 		const firstChar = path.charAt(0);
-		let matched = null;
 		for (let i = 0; i < node.children.length; i++) {
 			if (node.indices.charAt(i) !== firstChar) continue;
 			const child = node.children[i];
-			if (path.startsWith(child.path)) {
-				matched = child;
-				break;
-			}
-		}
-		if (matched) {
-			path = path.slice(matched.path.length);
-			node = matched;
-			continue;
+			if (!path.startsWith(child.path)) continue;
+			const result = search(child, method, path.slice(child.path.length));
+			if (result) return result;
 		}
 		if (node.paramChild) {
 			const slashIndex = path.indexOf("/");
 			const value = slashIndex === -1 ? path : path.slice(0, slashIndex);
-			if (value.length === 0) return null;
-			params[node.paramChild.paramName] = decodeURIComponent(value);
-			path = slashIndex === -1 ? "" : path.slice(slashIndex);
-			node = node.paramChild;
-			continue;
+			if (value.length > 0) {
+				const rest = slashIndex === -1 ? "" : path.slice(slashIndex);
+				const result = search(node.paramChild, method, rest);
+				if (result) {
+					result.params[node.paramChild.paramName] = decodeURIComponent(value);
+					return result;
+				}
+			}
 		}
-		return null;
 	}
-	if (!node.methods) return null;
-	const payload = node.methods.get(method);
-	if (payload === void 0) return null;
-	return {
-		payload,
-		params
-	};
+	if (node.wildcardChild) {
+		const payload = node.wildcardChild.methods?.get(method);
+		if (payload !== void 0) return {
+			payload,
+			params: { "*": decodeURIComponent(path) }
+		};
+	}
+	return null;
+}
+function lookupRoute(root, method, pathname) {
+	return search(root, method, pathname);
 }
 function joinPath(prefix, path) {
 	if (!prefix) return path;

package/dist/rhythm-router.d.ts

@@ -4,13 +4,24 @@ import { DeriveMiddleware, Middleware } from "@rhythmjs/rhythm/types";
 export interface RhythmRouterContext {
   readonly params: Readonly<Record<string, string>>;
 }
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
 export interface RhythmRouterOptions {
   prefix?: string;
 }
+export type RouterEntry = {
+  readonly kind: "middleware";
+  readonly fn: Middleware<any>;
+} | {
+  readonly kind: "route";
+  readonly method: HttpMethod;
+  readonly path: string;
+  readonly handlers: readonly Middleware<any>[];
+};
 type RouteHandler<TContext> = Middleware<TContext & RhythmRouterContext>;
 export declare class RhythmRouter<TContext extends RhythmHttpContext = RhythmHttpContext> {
   #private;
   constructor(options?: RhythmRouterOptions);
+  get entries(): readonly RouterEntry[];
   use<TExtra extends object>(fn: DeriveMiddleware<TContext, TExtra>): RhythmRouter<TContext & TExtra>;
   use(fn: Middleware<TContext>): this;
   get<TExtra extends object>(path: string, middleware: DeriveMiddleware<TContext & RhythmRouterContext, TExtra>, ...handlers: RouteHandler<TContext & TExtra>[]): this;

package/dist/rhythm-router.js

@@ -10,6 +10,9 @@ var RhythmRouter = class {
 	get #prefix() {
 		return this.#options.prefix ?? "";
 	}
+	get entries() {
+		return [...this.#entries];
+	}
 	use(fn) {
 		if (typeof fn !== "function") throw new TypeError("middleware must be a function!");
 		this.#entries.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhythmjs/router",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Radix-tree HTTP router for the Rhythm middleware kernel, with Bun, Node, and Deno adapters.",
   "homepage": "https://rhythm.js.org/router",
   "license": "ISC",
@@ -49,7 +49,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@rhythmjs/rhythm": "0.0.4"
+    "@rhythmjs/rhythm": "0.0.6"
   },
   "devDependencies": {
     "@types/node": "^26.6.3",