@fraqjs/fraq 0.7.0 → 0.8.1

package/README.md

@@ -27,15 +27,15 @@ const ctx = Context.fromUrl('<替换成你的 Milky 协议端地址>', {
   // accessToken: '<如果你的 Milky 协议端配置了 token，请在这里添加>',
 });
 
-ctx.router.command(
-  'echo',
-  {
+ctx.router.command({
+  name: 'echo',
+  pattern: {
     content: param.greedy(),
   },
-  (session, { content }) => {
+  execute(session, { content }) {
     session.reply(msg`You said: ${content}`);
   },
-);
+});
 
 ctx.start();
 ```

package/dist/index.d.mts

@@ -5444,12 +5444,14 @@ declare class Tokenizer {
   next(): Token | undefined;
   isGreedyAvailable(): boolean;
   greedy(): string;
+  isCatchAllAvailable(): boolean;
+  catchAll(): IncomingSegment[];
   private findNextPosition;
   private findTextTokenStart;
   private readTextToken;
 }
 //#endregion
-//#region src/routing/capturer.d.ts
+//#region src/routing/parameter.d.ts
 interface Capturer<T> {
   typeInstruction: TypeInstruction;
   capture(tokenizer: Tokenizer): T | undefined;
@@ -5468,6 +5470,9 @@ type TypeInstruction =
   | {
       type: 'greedy';
     }
+  | {
+      type: 'catchAll';
+    }
   | {
       type: 'union';
       members: string[];
@@ -5476,8 +5481,6 @@ type TypeInstruction =
       type: 'segment';
       segmentType: Exclude<Token, string>['type'];
     };
-//#endregion
-//#region src/routing/parameter.d.ts
 declare class Parameter<T> {
   readonly capturer: Capturer<T>;
   description?: string;
@@ -5489,6 +5492,7 @@ declare namespace param {
   function num(): Parameter<number>;
   function str(): Parameter<string>;
   function greedy(): Parameter<string>;
+  function catchAll(): Parameter<IncomingSegment[]>;
   function union<T extends string>(...literals: T[]): Parameter<T>;
   function segment<T extends Exclude<Token, string>['type']>(
     type: T,
@@ -5505,21 +5509,21 @@ declare namespace param {
 //#region src/routing/router.d.ts
 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 Executor<P extends Pattern> = (session: Session, params: ParamsOf<P>) => void | Promise<void>;
 type SessionPredicate = (session: Session) => boolean;
-interface Command {
+interface Command<P extends Pattern> {
   name: string;
-  pattern: Pattern;
-  handler: (session: Session, params: any) => void | Promise<void>;
+  pattern: P;
+  execute: Executor<P>;
 }
-interface RawPattern {
-  pattern: Pattern;
-  handler: (session: Session, params: any) => void | Promise<void>;
+interface RawPattern<P extends Pattern> {
+  pattern: P;
+  execute: Executor<P>;
 }
 type RouteEntry =
   | {
       type: 'command';
-      command: Command;
+      command: Command<Pattern>;
     }
   | {
       type: 'group';
@@ -5533,30 +5537,30 @@ type RouteEntry =
     }
   | {
       type: 'rawPattern';
-      rawPattern: RawPattern;
+      rawPattern: RawPattern<Pattern>;
     };
 type RouteBranch =
   | {
       type: 'command';
       path: string[];
-      command: Command;
+      command: Command<Pattern>;
     }
   | {
       type: 'rawPattern';
       path: string[];
-      rawPattern: RawPattern;
+      rawPattern: RawPattern<Pattern>;
     };
 type RouteMatchResult =
   | {
       type: 'command';
       path: string[];
-      command: Command;
+      command: Command<Pattern>;
       params: any;
     }
   | {
       type: 'rawPattern';
       path: string[];
-      rawPattern: RawPattern;
+      rawPattern: RawPattern<Pattern>;
       params: any;
     };
 interface Session {
@@ -5566,8 +5570,8 @@ interface Session {
 declare class Router {
   private readonly entries;
   private readonly groups;
-  command<P extends Pattern>(name: string, pattern: P, handler: Handler<P>): this;
-  rawPattern<P extends Pattern>(pattern: P, handler: Handler<P>): this;
+  command<P extends Pattern>(command: Command<P>): this;
+  rawPattern<P extends Pattern>(rawPattern: RawPattern<P>): this;
   group(name: string): Router;
   filter(predicate: SessionPredicate): Router;
   routes(): RouteEntry[];
@@ -5580,6 +5584,7 @@ declare class Router {
   private matchGroup;
   private matchRawPattern;
   private branchesFrom;
+  private validatePattern;
   private capturePattern;
 }
 //#endregion
@@ -5775,14 +5780,15 @@ declare namespace seg {
 //#endregion
 export {
   ApiEndpoints,
+  Capturer,
   Command,
   Context,
   ContextOptions,
   ContextUrlOptions,
   Disposable,
   EventMap,
+  Executor,
   Filter,
-  Handler,
   Injection,
   LogHandler,
   LogLevel,
@@ -5803,6 +5809,7 @@ export {
   ServiceClass,
   Session,
   SessionPredicate,
+  TypeInstruction,
   combineLogHandlers,
   createMilkyClient,
   definePlugin,

package/dist/index.mjs

@@ -115,21 +115,48 @@ var Tokenizer = class {
 		return token;
 	}
 	isGreedyAvailable() {
-		if (this.offset !== this.segments.length - 1) return false;
-		const segment = this.segments[this.offset];
+		const position = this.findNextPosition();
+		if (position === void 0) return false;
+		const segment = this.segments[position.offset];
 		if (segment?.type !== "text") return false;
-		return this.findTextTokenStart(segment.data.text, this.subOffset ?? 0) < segment.data.text.length;
+		return this.findTextTokenStart(segment.data.text, position.subOffset ?? 0) < segment.data.text.length;
 	}
 	greedy() {
-		if (!this.isGreedyAvailable()) throw new Error("Greedy token is not available");
-		const segment = this.segments[this.offset];
+		const position = this.findNextPosition();
+		if (position === void 0) throw new Error("Greedy token is not available");
+		const segment = this.segments[position.offset];
 		if (segment.type !== "text") throw new Error("Greedy token is not available");
-		const tokenStart = this.findTextTokenStart(segment.data.text, this.subOffset ?? 0);
+		const tokenStart = this.findTextTokenStart(segment.data.text, position.subOffset ?? 0);
+		if (tokenStart >= segment.data.text.length) throw new Error("Greedy token is not available");
 		const token = segment.data.text.slice(tokenStart);
-		this.offset = this.segments.length;
+		this.offset = position.offset + 1;
 		this.subOffset = void 0;
 		return token;
 	}
+	isCatchAllAvailable() {
+		return this.findNextPosition() !== void 0;
+	}
+	catchAll() {
+		const position = this.findNextPosition();
+		if (position === void 0) throw new Error("Catch-all token is not available");
+		const segment = this.segments[position.offset];
+		const segments = [];
+		if (segment.type === "text") {
+			const textStart = this.findTextTokenStart(segment.data.text, position.subOffset ?? 0);
+			const text = segment.data.text.slice(textStart);
+			if (text.length > 0) segments.push({
+				...segment,
+				data: {
+					...segment.data,
+					text
+				}
+			});
+			segments.push(...this.segments.slice(position.offset + 1));
+		} else segments.push(...this.segments.slice(position.offset));
+		this.offset = this.segments.length;
+		this.subOffset = void 0;
+		return segments;
+	}
 	findNextPosition() {
 		let offset = this.offset;
 		let subOffset = this.subOffset;
@@ -164,25 +191,16 @@ var Tokenizer = class {
 var Router = class Router {
 	entries = [];
 	groups = /* @__PURE__ */ new Map();
-	command(name, pattern, handler) {
-		const command = {
-			name,
-			pattern,
-			handler
-		};
+	command(command) {
+		this.validatePattern(command.pattern);
 		this.entries.push({
 			type: "command",
 			command
 		});
 		return this;
 	}
-	rawPattern(pattern, handler) {
-		if (Object.keys(pattern).length === 0) throw new Error("Raw pattern must have at least one parameter.");
-		if (pattern[Object.keys(pattern)[0]].capturer.typeInstruction.type === "literal") throw new Error("The first parameter of a raw pattern cannot be a literal, as it would conflict with command patterns.");
-		const rawPattern = {
-			pattern,
-			handler
-		};
+	rawPattern(rawPattern) {
+		this.validatePattern(rawPattern.pattern, { rawPattern: true });
 		this.entries.push({
 			type: "rawPattern",
 			rawPattern
@@ -226,10 +244,10 @@ var Router = class Router {
 		if (match === void 0) return false;
 		switch (match.type) {
 			case "command":
-				await match.command.handler(session, match.params);
+				await match.command.execute(session, match.params);
 				break;
 			case "rawPattern":
-				await match.rawPattern.handler(session, match.params);
+				await match.rawPattern.execute(session, match.params);
 				break;
 		}
 		return true;
@@ -308,6 +326,15 @@ var Router = class Router {
 		}
 		return branches;
 	}
+	validatePattern(pattern, options) {
+		const entries = Object.entries(pattern);
+		if (options?.rawPattern && entries.length === 0) throw new Error("Raw pattern must have at least one parameter.");
+		if (options?.rawPattern && entries[0]?.[1].capturer.typeInstruction.type === "literal") throw new Error("The first parameter of a raw pattern cannot be a literal, as it would conflict with command patterns.");
+		const catchAllEntryIndex = entries.findIndex(([, parameter]) => {
+			return parameter.capturer.typeInstruction.type === "catchAll";
+		});
+		if (catchAllEntryIndex !== -1 && catchAllEntryIndex !== entries.length - 1) throw new Error("Catch-all parameters must be the last parameter in a pattern.");
+	}
 	capturePattern(pattern, tokenizer) {
 		const initialState = tokenizer.getState();
 		const params = {};
@@ -1060,11 +1087,22 @@ let seg;
 const milkyVersion = "1.3";
 const milkyPackageVersion = "1.3.0-rc.1";
 //#endregion
-//#region src/routing/capturer.ts
-let capturer;
-(function(_capturer) {
+//#region src/routing/parameter.ts
+var Parameter = class {
+	capturer;
+	description;
+	constructor(capturer) {
+		this.capturer = capturer;
+	}
+	describe(description) {
+		this.description = description;
+		return this;
+	}
+};
+let param;
+(function(_param) {
 	function literal(literal) {
-		return {
+		return new Parameter({
 			typeInstruction: {
 				type: "literal",
 				literal
@@ -1076,44 +1114,62 @@ let capturer;
 					return token;
 				}
 			}
-		};
+		});
 	}
-	_capturer.literal = literal;
-	_capturer.num = {
-		typeInstruction: { type: "number" },
-		capture(tokenizer) {
-			const token = tokenizer.peek();
-			if (typeof token === "string") {
-				const parsed = Number(token);
-				if (!Number.isNaN(parsed)) {
+	_param.literal = literal;
+	function num() {
+		return new Parameter({
+			typeInstruction: { type: "number" },
+			capture(tokenizer) {
+				const token = tokenizer.peek();
+				if (typeof token === "string") {
+					const parsed = Number(token);
+					if (!Number.isNaN(parsed)) {
+						tokenizer.next();
+						return parsed;
+					}
+				}
+			}
+		});
+	}
+	_param.num = num;
+	function str() {
+		return new Parameter({
+			typeInstruction: { type: "string" },
+			capture(tokenizer) {
+				const token = tokenizer.peek();
+				if (typeof token === "string") {
 					tokenizer.next();
-					return parsed;
+					return token;
 				}
 			}
-		}
-	};
-	_capturer.str = {
-		typeInstruction: { type: "string" },
-		capture(tokenizer) {
-			const token = tokenizer.peek();
-			if (typeof token === "string") {
-				tokenizer.next();
-				return token;
+		});
+	}
+	_param.str = str;
+	function greedy() {
+		return new Parameter({
+			typeInstruction: { type: "greedy" },
+			capture(tokenizer) {
+				if (tokenizer.isGreedyAvailable()) return tokenizer.greedy();
 			}
-		}
-	};
-	_capturer.greedy = {
-		typeInstruction: { type: "greedy" },
-		capture(tokenizer) {
-			if (tokenizer.isGreedyAvailable()) return tokenizer.greedy();
-		}
-	};
-	function union(...members) {
-		const literalSet = new Set(members);
-		return {
+		});
+	}
+	_param.greedy = greedy;
+	function catchAll() {
+		return new Parameter({
+			typeInstruction: { type: "catchAll" },
+			capture(tokenizer) {
+				if (tokenizer.isCatchAllAvailable()) return tokenizer.catchAll();
+			}
+		});
+	}
+	_param.catchAll = catchAll;
+	function union(...literals) {
+		const literalSet = new Set(literals);
+		return new Parameter({
 			typeInstruction: {
 				type: "union",
-				members
+				members: literals
 			},
 			capture(tokenizer) {
 				const token = tokenizer.peek();
@@ -1122,11 +1178,11 @@ let capturer;
 					return token;
 				}
 			}
-		};
+		});
 	}
-	_capturer.union = union;
+	_param.union = union;
 	function segment(type) {
-		return {
+		return new Parameter({
 			typeInstruction: {
 				type: "segment",
 				segmentType: type
@@ -1138,47 +1194,7 @@ let capturer;
 					return token;
 				}
 			}
-		};
-	}
-	_capturer.segment = segment;
-})(capturer || (capturer = {}));
-//#endregion
-//#region src/routing/parameter.ts
-var Parameter = class {
-	capturer;
-	description;
-	constructor(capturer) {
-		this.capturer = capturer;
-	}
-	describe(description) {
-		this.description = description;
-		return this;
-	}
-};
-let param;
-(function(_param) {
-	function literal(literal) {
-		return new Parameter(capturer.literal(literal));
-	}
-	_param.literal = literal;
-	function num() {
-		return new Parameter(capturer.num);
-	}
-	_param.num = num;
-	function str() {
-		return new Parameter(capturer.str);
-	}
-	_param.str = str;
-	function greedy() {
-		return new Parameter(capturer.greedy);
-	}
-	_param.greedy = greedy;
-	function union(...literals) {
-		return new Parameter(capturer.union(...literals));
-	}
-	_param.union = union;
-	function segment(type) {
-		return new Parameter(capturer.segment(type));
+		});
 	}
 	_param.segment = segment;
 })(param || (param = {}));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fraqjs/fraq",
   "type": "module",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Milky Bot framework",
   "files": [
     "dist"