@fraqjs/fraq 0.6.4 → 0.8.0

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

@@ -5505,21 +5505,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 +5533,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 +5566,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[];
@@ -5679,6 +5679,7 @@ declare class Context {
   private readonly services;
   private readonly subContexts;
   private readonly parentEventForwarder?;
+  private readonly timers;
   private readonly initialReconnectDelayMs;
   private readonly maxReconnectDelayMs;
   private readonly logHandler?;
@@ -5700,12 +5701,17 @@ 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;
+  timeout(delayMs: number, callback: () => void | Promise<void>): NodeJS.Timeout;
+  interval(intervalMs: number, callback: () => void | Promise<void>): NodeJS.Timeout;
   createSession(message: IncomingMessage): Session;
   start(): Promise<void>;
   stop(): Promise<void>;
   private startInternal;
   private getState;
   private stopInternal;
+  private assertCanScheduleTimer;
+  private runTimerCallback;
+  private clearTimers;
   private stopEventStream;
   private acceptsParentEvent;
   private applyPlugins;
@@ -5775,8 +5781,8 @@ export {
   ContextUrlOptions,
   Disposable,
   EventMap,
+  Executor,
   Filter,
-  Handler,
   Injection,
   LogHandler,
   LogLevel,

package/dist/index.mjs

@@ -164,25 +164,17 @@ var Tokenizer = class {
 var Router = class Router {
 	entries = [];
 	groups = /* @__PURE__ */ new Map();
-	command(name, pattern, handler) {
-		const command = {
-			name,
-			pattern,
-			handler
-		};
+	command(command) {
 		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) {
+		if (Object.keys(rawPattern.pattern).length === 0) throw new Error("Raw pattern must have at least one parameter.");
+		const firstKey = Object.keys(rawPattern.pattern)[0];
+		if (rawPattern.pattern[firstKey].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.");
 		this.entries.push({
 			type: "rawPattern",
 			rawPattern
@@ -226,10 +218,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;
@@ -382,6 +374,7 @@ var Context = class Context {
 	services = /* @__PURE__ */ new Map();
 	subContexts = [];
 	parentEventForwarder;
+	timers = /* @__PURE__ */ new Set();
 	initialReconnectDelayMs;
 	maxReconnectDelayMs;
 	logHandler;
@@ -466,6 +459,23 @@ and implement the dispose method to clean up resources when the context stops.
 		this.subContexts.push(subContext);
 		return subContext;
 	}
+	timeout(delayMs, callback) {
+		this.assertCanScheduleTimer();
+		const timeout = setTimeout(() => {
+			this.timers.delete(timeout);
+			this.runTimerCallback(callback);
+		}, delayMs);
+		this.timers.add(timeout);
+		return timeout;
+	}
+	interval(intervalMs, callback) {
+		this.assertCanScheduleTimer();
+		const interval = setInterval(() => {
+			this.runTimerCallback(callback);
+		}, intervalMs);
+		this.timers.add(interval);
+		return interval;
+	}
 	createSession(message) {
 		return {
 			raw: message,
@@ -508,10 +518,10 @@ and implement the dispose method to clean up resources when the context stops.
 		}
 	}
 	async stop() {
-		if (this.state === "idle" || this.state === "stopped") return;
+		if (this.state === "idle" && this.timers.size === 0 || this.state === "stopped") return;
 		if (this.state === "starting") await this.startPromise;
 		const stateAfterStart = this.getState();
-		if (stateAfterStart === "idle" || stateAfterStart === "stopped") return;
+		if (stateAfterStart === "idle" && this.timers.size === 0 || stateAfterStart === "stopped") return;
 		if (stateAfterStart === "stopping") {
 			await this.stopPromise;
 			return;
@@ -543,12 +553,13 @@ and implement the dispose method to clean up resources when the context stops.
 	}
 	async stopInternal() {
 		const errors = [];
-		await this.stopEventStream(errors);
+		this.clearTimers();
 		for (const subContext of [...this.subContexts].reverse()) try {
 			await subContext.stop();
 		} catch (error) {
 			errors.push(error);
 		}
+		await this.stopEventStream(errors);
 		if (this.parent && this.parentEventForwarder) this.parent.eventBus.off("*", this.parentEventForwarder);
 		for (const service of [...this.services.values()].reverse()) {
 			if (!isDisposable(service)) continue;
@@ -561,6 +572,22 @@ and implement the dispose method to clean up resources when the context stops.
 		if (errors.length === 1) throw errors[0];
 		if (errors.length > 1) throw new AggregateError(errors, `Context "${this.name}" failed to stop cleanly.`);
 	}
+	assertCanScheduleTimer() {
+		if (this.state === "stopping") throw new Error(`Context "${this.name}" cannot schedule timers while it is stopping.`);
+		if (this.state === "stopped") throw new Error(`Context "${this.name}" cannot schedule timers after it has stopped.`);
+	}
+	async runTimerCallback(callback) {
+		if (this.state === "stopping" || this.state === "stopped") return;
+		try {
+			await callback();
+		} catch (error) {
+			this.logger.error("Error handling timer callback", error);
+		}
+	}
+	clearTimers() {
+		for (const timer of this.timers) clearTimeout(timer);
+		this.timers.clear();
+	}
 	async stopEventStream(errors) {
 		this.resolveReconnectDelay();
 		const subscription = this.eventSubscription;
@@ -685,6 +712,10 @@ and implement the dispose method to clean up resources when the context stops.
 	}
 	createProxyContextForPlugin(plugin) {
 		const proxyLogger = new Logger((message) => this.logHandler?.(message), plugin.name);
+		const proxyProvide = (service, instance) => {
+			this.provide(service, instance);
+			this.logger.debug(`Plugin ${plugin.name} provided ${service.name}`);
+		};
 		let proxyInjections;
 		if (plugin.inject) {
 			proxyInjections = {};
@@ -694,10 +725,11 @@ and implement the dispose method to clean up resources when the context stops.
 			proxyInjections ??= {};
 			for (const [key, service] of Object.entries(plugin.optionalInject)) proxyInjections[key] = this.tryResolve(service);
 		}
-		return new Proxy(this, { get(target, prop) {
+		return new Proxy(this, { get(target, prop, receiver) {
 			if (prop === "logger") return proxyLogger;
+			else if (prop === "provide") return proxyProvide;
 			else if (proxyInjections && prop in proxyInjections) return proxyInjections[prop];
-			else return target[prop];
+			else return Reflect.get(target, prop, receiver);
 		} });
 	}
 	async runEventStream() {

package/package.json

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