feat!: remove errorHandler

Author: so1ve

src/chain.ts

@@ -1,21 +1,13 @@
 import type {
-	ErrorHandler,
 	EventMap,
 	Listener,
 	OffFunction,
-	Options,
 	WildcardListener,
 } from "./types";
 
 export class LiteEmit<EM extends EventMap = EventMap> {
 	#listenerMap = new Map<keyof EM, Listener<EM[keyof EM]>[]>();
 	#wildcardListeners: WildcardListener[] = [];
-	#errorHandler: ErrorHandler | undefined;
-
-	constructor(options?: Options) {
-		this.#errorHandler = options?.errorHandler;
-	}
-
 	public on(event: "*", listener: WildcardListener): OffFunction;
 	public on<K extends keyof EM>(
 		event: K,
@@ -61,31 +53,25 @@ export class LiteEmit<EM extends EventMap = EventMap> {
 		return this.on(event, onceListener);
 	}
 
-	#callListenerWithErrorHandler(listener: Listener<any>, args: any[]): void {
-		try {
-			const result = listener(...args);
-			if (result instanceof Promise) {
-				result.catch((e) => {
-					this.#errorHandler?.(e);
-				});
-			}
-		} catch (e: unknown) {
-			this.#errorHandler?.(e);
-		}
-	}
+	public async emit<K extends keyof EM>(
+		event: K,
+		...args: EM[K]
+	): Promise<void> {
+		const results: any[] = [];
 
-	public emit<K extends keyof EM>(event: K, ...args: EM[K]): void {
 		if (this.#wildcardListeners.length > 0) {
 			for (const listener of this.#wildcardListeners) {
-				this.#callListenerWithErrorHandler(listener, [event, ...args]);
+				results.push(listener(event as any, ...args));
 			}
 		}
 		const listeners = this.#listenerMap.get(event);
 		if (listeners) {
 			for (const listener of listeners) {
-				this.#callListenerWithErrorHandler(listener, args);
+				results.push(listener(...args));
 			}
 		}
+
+		return Promise.all(results).then(() => {});
 	}
 
 	public off(): void;

src/emitter.ts

@@ -1,4 +1,2 @@
-export type { ChainedLiteEmit } from "./chain";
-export { chain } from "./chain";
 export { LiteEmit } from "./emitter";
 export type * from "./types";

src/index.ts

@@ -1,8 +1,4 @@
 export type EventMap = Record<PropertyKey, any[]>;
 export type Listener<A extends any[]> = (...args: A) => void | Promise<void>;
 export type WildcardListener = Listener<[event: string, ...args: string[]]>;
-export type ErrorHandler = (e: unknown) => void;
-export interface Options {
-	errorHandler?: ErrorHandler;
-}
 export type OffFunction = () => void;

src/types.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 
-import { LiteEmit, chain } from "../src";
+import { LiteEmit } from "../src";
 
 // eslint-disable-next-line ts/consistent-type-definitions
 type EventMap = {
@@ -10,13 +10,13 @@ type EventMap = {
 	faq: [];
 	error: [];
 	error2: [];
+	asyncEvent: [string];
+	asyncEvent2: [number];
+	concurrentEvent: [string];
+	promiseErrorEvent: [];
 };
 
-const errorMsgs: string[] = [];
-
-const emitter = new LiteEmit<EventMap>({
-	errorHandler: (s: any) => errorMsgs.push(s.message),
-});
+const emitter = new LiteEmit<EventMap>();
 
 const Sym = Symbol("d");
 
@@ -136,120 +136,89 @@ describe("should", () => {
 		expect(count2).toBe(3);
 	});
 
-	it("errorHandler", () => {
-		emitter.on("error", () => {
-			throw new Error("Foo");
-		});
-		emitter.emit("error");
-
-		expect(errorMsgs[0]).toBe("Foo");
-	});
-
-	it("errorHandler async", () => {
-		emitter.on("error2", async () => {
-			throw new Error("Bar");
-		});
-		emitter.emit("error2");
+	describe("await functionality", () => {
+		it("should handle async listeners", async () => {
+			let asyncResult = "";
 
-		// Wait for async action
-		setTimeout(() => {
-			expect(errorMsgs[1]).toBe("Bar");
-		}, 500);
-	});
-});
-
-describe("chain", () => {
-	const Sym = Symbol("d");
-
-	it("should be chainable and work correctly", () => {
-		const emitter = new LiteEmit<EventMap>();
-		const chained = chain(emitter);
-		let onCount = 0;
-		let onceCount = 0;
-
-		chained
-			.on("foo", (str) => {
-				onCount++;
-
-				expect(str).toBe("foo");
-			})
-			.once("bar", (str, num, symbol) => {
-				onceCount++;
-
-				expect(str).toBe("bar");
-				expect(num).toBe(42);
-				expect(symbol).toBe(Sym);
+			emitter.on("asyncEvent", async (str: string) => {
+				await new Promise((resolve) => setTimeout(resolve, 10));
+				asyncResult = `${str}-processed`;
 			});
 
-		chained.emit("foo", "foo");
-
-		expect(onCount).toBe(1);
+			await emitter.emit("asyncEvent", "test");
 
-		chained.emit("bar", "bar", 42, Sym);
+			expect(asyncResult).toBe("test-processed");
+		});
 
-		expect(onceCount).toBe(1);
+		it("should return a Promise that can be awaited", async () => {
+			const executionOrder: number[] = [];
 
-		// once should not trigger again
-		chained.emit("bar", "bar", 42, Sym);
+			emitter.on("asyncEvent2", async (_num: number) => {
+				executionOrder.push(1);
+				await new Promise((resolve) => setTimeout(resolve, 10));
+				executionOrder.push(2);
+			});
 
-		expect(onceCount).toBe(1);
+			const promise = emitter.emit("asyncEvent2", 42);
 
-		// off should work
-		chained.off("foo").emit("foo", "foo");
+			expect(promise).toBeInstanceOf(Promise);
 
-		expect(onCount).toBe(1);
-	});
+			await promise;
 
-	it("should handle wildcard listeners", () => {
-		const emitter = new LiteEmit<EventMap>();
-		const chained = chain(emitter);
-		let wildcardCount = 0;
+			expect(executionOrder).toEqual([1, 2]);
+		});
 
-		chained
-			.on("*", () => {
-				wildcardCount++;
-			})
-			.emit("foo", "foo")
-			.emit("bar", "bar", 42, Sym);
+		it("should execute multiple async listeners concurrently", async () => {
+			const startTime = Date.now();
+			const delays: number[] = [];
 
-		expect(wildcardCount).toBe(2);
+			emitter.on("concurrentEvent", async (_str: string) => {
+				const start = Date.now();
+				await new Promise((resolve) => setTimeout(resolve, 50));
+				delays.push(Date.now() - start);
+			});
 
-		chained.off("*").emit("foo", "foo");
+			emitter.on("concurrentEvent", async (_str: string) => {
+				const start = Date.now();
+				await new Promise((resolve) => setTimeout(resolve, 30));
+				delays.push(Date.now() - start);
+			});
 
-		expect(wildcardCount).toBe(2);
-	});
+			await emitter.emit("concurrentEvent", "test");
+			const totalTime = Date.now() - startTime;
 
-	it("should handle off() to clear all listeners", () => {
-		const emitter = new LiteEmit<EventMap>();
-		const chained = chain(emitter);
-		let count = 0;
-		chained
-			.on("foo", () => {
-				count++;
-			})
-			.emit("foo", "foo");
+			// 并发执行，总时间应该接近最长的单个监听器时间，而不是所有时间的总和
+			expect(totalTime).toBeLessThan(80); // 50ms + 30ms = 80ms，但并发执行应该更少
+			expect(delays).toHaveLength(2);
+		});
 
-		expect(count).toBe(1);
+		it("should handle errors in async listeners", async () => {
+			emitter.on("promiseErrorEvent", async () => {
+				throw new Error("Async error");
+			});
 
-		chained.off().emit("foo", "foo");
+			await expect(async () => {
+				await emitter.emit("promiseErrorEvent");
+			}).rejects.toThrowError("Async error");
+		});
 
-		expect(count).toBe(1);
-	});
+		it("should work with mixed sync and async listeners", async () => {
+			let syncResult = "";
+			let asyncResult = "";
 
-	it("should unwrap to the original emitter", () => {
-		const emitter = new LiteEmit<EventMap>();
-		const chained = chain(emitter);
+			emitter.on("asyncEvent", (str: string) => {
+				syncResult = `${str}-sync`;
+			});
 
-		expect(chained.unwrap()).toBe(emitter);
+			emitter.on("asyncEvent", async (str: string) => {
+				await new Promise((resolve) => setTimeout(resolve, 10));
+				asyncResult = `${str}-async`;
+			});
 
-		// Verify that operations on the unwrapped emitter are reflected
-		let count = 0;
-		chained
-			.on("foo", () => {
-				count++;
-			})
-			.emit("foo", "foo");
+			await emitter.emit("asyncEvent", "mixed");
 
-		expect(count).toBe(1);
+			expect(syncResult).toBe("mixed-sync");
+			expect(asyncResult).toBe("mixed-async");
+		});
 	});
 });