@fraqjs/fraq 0.4.0 → 0.5.1

package/dist/index.d.mts

@@ -5507,6 +5507,58 @@ type Pattern = Record<string, Parameter<any>>;
 type ParamsOf<P extends Pattern> = { [K in keyof P]: P[K] extends Parameter<infer T> ? T : never };
 type Handler<P extends Pattern> = (session: Session, params: ParamsOf<P>) => void | Promise<void>;
 type SessionPredicate = (session: Session) => boolean;
+interface Command {
+  name: string;
+  pattern: Pattern;
+  handler: (session: Session, params: any) => void | Promise<void>;
+}
+interface RawPattern {
+  pattern: Pattern;
+  handler: (session: Session, params: any) => void | Promise<void>;
+}
+type RouteEntry =
+  | {
+      type: 'command';
+      command: Command;
+    }
+  | {
+      type: 'group';
+      name: string;
+      router: Router;
+    }
+  | {
+      type: 'filter';
+      predicate: SessionPredicate;
+      router: Router;
+    }
+  | {
+      type: 'rawPattern';
+      rawPattern: RawPattern;
+    };
+type RouteBranch =
+  | {
+      type: 'command';
+      path: string[];
+      command: Command;
+    }
+  | {
+      type: 'rawPattern';
+      path: string[];
+      rawPattern: RawPattern;
+    };
+type RouteMatchResult =
+  | {
+      type: 'command';
+      path: string[];
+      command: Command;
+      params: any;
+    }
+  | {
+      type: 'rawPattern';
+      path: string[];
+      rawPattern: RawPattern;
+      params: any;
+    };
 interface Session {
   raw: IncomingMessage;
   reply(segments: OutgoingSegment_ZodInput[]): Promise<void>;
@@ -5518,12 +5570,16 @@ declare class Router {
   rawPattern<P extends Pattern>(pattern: P, handler: Handler<P>): this;
   group(name: string): Router;
   filter(predicate: SessionPredicate): Router;
+  routes(): RouteEntry[];
+  branches(session: Session): RouteBranch[];
+  match(session: Session, message: IncomingMessage): RouteMatchResult | undefined;
   dispatch(session: Session, message: IncomingMessage): Promise<boolean>;
-  private process;
-  private processEntry;
-  private processCommand;
-  private processGroup;
-  private processRawPattern;
+  private matchFrom;
+  private matchEntry;
+  private matchCommand;
+  private matchGroup;
+  private matchRawPattern;
+  private branchesFrom;
   private capturePattern;
 }
 //#endregion
@@ -5630,6 +5686,7 @@ declare class Context {
   tryResolve<T extends object>(service: ServiceClass<T>): T | undefined;
   isProvided<T extends object>(service: ServiceClass<T>): boolean;
   fork(name: string, filter?: Filter): Context;
+  createSession(message: IncomingMessage): Session;
   start(): Promise<void>;
   private acceptsParentEvent;
   private applyPlugins;
@@ -5641,7 +5698,6 @@ declare class Context {
   private createUnresolvablePluginError;
   private createProxyContextForPlugin;
   private runEventStream;
-  private createSession;
   static fromUrl(baseUrl: string | URL, options?: ContextOptions & ContextUrlOptions): Context;
   static fromClient(client: MilkyClient, options?: ContextOptions): Context;
 }
@@ -5688,11 +5744,13 @@ declare namespace seg {
 //#endregion
 export {
   ApiEndpoints,
+  Command,
   Context,
   ContextOptions,
   ContextUrlOptions,
   EventMap,
   Filter,
+  Handler,
   Injection,
   LogHandler,
   LogLevel,
@@ -5702,10 +5760,17 @@ export {
   MilkyEventSubscription,
   Parameter,
   ParameterList,
+  ParamsOf,
+  Pattern,
   Plugin,
+  RawPattern,
+  RouteBranch,
+  RouteEntry,
+  RouteMatchResult,
   Router,
   type ServiceClass,
   Session,
+  SessionPredicate,
   combineLogHandlers,
   createMilkyClient,
   definePlugin,

package/dist/index.mjs

@@ -211,49 +211,102 @@ var Router = class Router {
 		});
 		return router;
 	}
-	async dispatch(session, message) {
+	routes() {
+		return this.entries;
+	}
+	branches(session) {
+		return this.branchesFrom(session, []);
+	}
+	match(session, message) {
 		const tokenizer = new Tokenizer(message.segments);
-		return await this.process(session, tokenizer);
+		return this.matchFrom(session, tokenizer, []);
 	}
-	async process(session, tokenizer) {
+	async dispatch(session, message) {
+		const match = this.match(session, message);
+		if (match === void 0) return false;
+		switch (match.type) {
+			case "command":
+				await match.command.handler(session, match.params);
+				break;
+			case "rawPattern":
+				await match.rawPattern.handler(session, match.params);
+				break;
+		}
+		return true;
+	}
+	matchFrom(session, tokenizer, path) {
 		const initialState = tokenizer.getState();
 		for (const entry of this.entries) {
 			tokenizer.setState(initialState);
-			if (await this.processEntry(entry, session, tokenizer)) return true;
+			const match = this.matchEntry(entry, session, tokenizer, path);
+			if (match !== void 0) return match;
 		}
 		tokenizer.setState(initialState);
-		return false;
 	}
-	async processEntry(entry, session, tokenizer) {
+	matchEntry(entry, session, tokenizer, path) {
 		switch (entry.type) {
-			case "command": return await this.processCommand(entry.command, session, tokenizer);
-			case "group": return await this.processGroup(entry.name, entry.router, session, tokenizer);
+			case "command": return this.matchCommand(entry.command, tokenizer, path);
+			case "group": return this.matchGroup(entry.name, entry.router, session, tokenizer, path);
 			case "filter":
-				if (entry.predicate(session) !== true) return false;
-				return await entry.router.process(session, tokenizer);
-			case "rawPattern": return await this.processRawPattern(entry.rawPattern, session, tokenizer);
+				if (entry.predicate(session) !== true) return;
+				return entry.router.matchFrom(session, tokenizer, path);
+			case "rawPattern": return this.matchRawPattern(entry.rawPattern, tokenizer, path);
 		}
 	}
-	async processCommand(command, session, tokenizer) {
+	matchCommand(command, tokenizer, path) {
 		const token = tokenizer.peek();
-		if (typeof token !== "string" || token !== command.name) return false;
+		if (typeof token !== "string" || token !== command.name) return;
 		tokenizer.next();
 		const params = this.capturePattern(command.pattern, tokenizer);
-		if (params === void 0 || tokenizer.hasNext()) return false;
-		await command.handler(session, params);
-		return true;
+		if (params === void 0 || tokenizer.hasNext()) return;
+		return {
+			type: "command",
+			path: [...path],
+			command,
+			params
+		};
 	}
-	async processGroup(name, router, session, tokenizer) {
+	matchGroup(name, router, session, tokenizer, path) {
 		const token = tokenizer.peek();
-		if (typeof token !== "string" || token !== name) return false;
+		if (typeof token !== "string" || token !== name) return;
 		tokenizer.next();
-		return await router.process(session, tokenizer);
+		return router.matchFrom(session, tokenizer, [...path, name]);
 	}
-	async processRawPattern(rawPattern, session, tokenizer) {
+	matchRawPattern(rawPattern, tokenizer, path) {
 		const params = this.capturePattern(rawPattern.pattern, tokenizer);
-		if (params === void 0 || tokenizer.hasNext()) return false;
-		await rawPattern.handler(session, params);
-		return true;
+		if (params === void 0 || tokenizer.hasNext()) return;
+		return {
+			type: "rawPattern",
+			path: [...path],
+			rawPattern,
+			params
+		};
+	}
+	branchesFrom(session, path) {
+		const branches = [];
+		for (const entry of this.entries) switch (entry.type) {
+			case "command":
+				branches.push({
+					type: "command",
+					path: [...path],
+					command: entry.command
+				});
+				break;
+			case "group":
+				branches.push(...entry.router.branchesFrom(session, [...path, entry.name]));
+				break;
+			case "filter":
+				if (entry.predicate(session) === true) branches.push(...entry.router.branchesFrom(session, path));
+				break;
+			case "rawPattern":
+				branches.push({
+					type: "rawPattern",
+					path: [...path],
+					rawPattern: entry.rawPattern
+				});
+				break;
+		}
+		return branches;
 	}
 	capturePattern(pattern, tokenizer) {
 		const initialState = tokenizer.getState();
@@ -386,6 +439,31 @@ var Context = class Context {
 		this.subContexts.push(subContext);
 		return subContext;
 	}
+	createSession(message) {
+		return {
+			raw: message,
+			reply: async (segments) => {
+				try {
+					switch (message.message_scene) {
+						case "friend":
+							await this.client.send_private_message({
+								user_id: message.peer_id,
+								message: segments
+							});
+							break;
+						case "group":
+							await this.client.send_group_message({
+								group_id: message.peer_id,
+								message: segments
+							});
+							break;
+					}
+				} catch (error) {
+					this.logger.error(`Error sending reply (source msg: scene=${message.message_scene} peer=${message.peer_id} sender=${message.sender_id} seq=${message.message_seq})`, error);
+				}
+			}
+		};
+	}
 	async start() {
 		if (this.isStarted) return;
 		await this.applyPlugins();
@@ -509,31 +587,6 @@ var Context = class Context {
 			reconnectAttempt += 1;
 		}
 	}
-	createSession(message) {
-		return {
-			raw: message,
-			reply: async (segments) => {
-				try {
-					switch (message.message_scene) {
-						case "friend":
-							await this.client.send_private_message({
-								user_id: message.peer_id,
-								message: segments
-							});
-							break;
-						case "group":
-							await this.client.send_group_message({
-								group_id: message.peer_id,
-								message: segments
-							});
-							break;
-					}
-				} catch (error) {
-					this.logger.error(`Error sending reply (source msg: scene=${message.message_scene} peer=${message.peer_id} sender=${message.sender_id} seq=${message.message_seq})`, error);
-				}
-			}
-		};
-	}
 	static fromUrl(baseUrl, options) {
 		return new Context(createMilkyClient(baseUrl, { accessToken: options?.accessToken }), options);
 	}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fraqjs/fraq",
   "type": "module",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Milky Bot framework",
   "files": [
     "dist"
@@ -19,6 +19,9 @@
   "dependencies": {
     "mitt": "^3.0.1"
   },
+  "devDependencies": {
+    "@fraqjs/mock": "^0.1.0"
+  },
   "engines": {
     "node": ">=22"
   },