feat: error handler

Author: so1ve

.eslintrc

@@ -1,3 +1,6 @@
 {
-	"extends": "@so1ve"
+	"extends": "@so1ve",
+	"rules": {
+		"etc/no-implicit-any-catch": "off"
+	}
 }

src/index.ts

@@ -1,6 +1,6 @@
 export type EventMap = Record<string | symbol, any[]>;
 
-export type Listener<A extends any[]> = (...args: A) => void;
+export type Listener<A extends any[]> = (...args: A) => void | Promise<void>;
 
 type _WildcardListener<
 	EM extends EventMap,
@@ -13,9 +13,18 @@ export type ListenerMap<EM extends EventMap> = Map<
 	Set<Listener<EM[keyof EM]>>
 >;
 
+export interface LiteEmitOptions {
+	errorHandler?: (msg: string) => void;
+}
+
 export class LiteEmit<EM extends EventMap = EventMap> {
-	private listenerMap = new Map() as ListenerMap<EM>;
-	private wildcardListeners = new Set<WildcardListener<EM>>();
+	#listenerMap = new Map() as ListenerMap<EM>;
+	#wildcardListeners = new Set<WildcardListener<EM>>();
+	#errorHandler: ((msg: string) => void) | undefined;
+
+	constructor(options?: LiteEmitOptions) {
+		this.#errorHandler = options?.errorHandler;
+	}
 
 	on(event: "*", listener: WildcardListener<EM>): this;
 	on<K extends keyof EM>(event: K, listener: Listener<EM[K]>): this;
@@ -24,14 +33,14 @@ export class LiteEmit<EM extends EventMap = EventMap> {
 		listener: Listener<EM[K]> | WildcardListener<EM>,
 	): this {
 		if (event === "*") {
-			this.wildcardListeners.add(listener as WildcardListener<EM>);
+			this.#wildcardListeners.add(listener as WildcardListener<EM>);
 
 			return this;
 		}
-		if (!this.listenerMap.has(event)) {
-			this.listenerMap.set(event, new Set());
+		if (!this.#listenerMap.has(event)) {
+			this.#listenerMap.set(event, new Set());
 		}
-		this.listenerMap.get(event)!.add(listener as any);
+		this.#listenerMap.get(event)!.add(listener as any);
 
 		return this;
 	}
@@ -51,12 +60,30 @@ export class LiteEmit<EM extends EventMap = EventMap> {
 	}
 
 	emit<K extends keyof EM>(event: K, ...args: EM[K]): this {
-		if (this.listenerMap.has(event)) {
-			for (const listener of this.wildcardListeners) {
-				listener(event, ...args);
+		if (this.#listenerMap.has(event)) {
+			for (const listener of this.#wildcardListeners) {
+				try {
+					const result = listener(event, ...args);
+					if (result instanceof Promise) {
+						result.catch((e) => {
+							this.#errorHandler?.(e.message);
+						});
+					}
+				} catch (e: any) {
+					this.#errorHandler?.(e.message);
+				}
 			}
-			for (const listener of this.listenerMap.get(event)!) {
-				listener(...args);
+			for (const listener of this.#listenerMap.get(event)!) {
+				try {
+					const result = listener(...args);
+					if (result instanceof Promise) {
+						result.catch((e) => {
+							this.#errorHandler?.(e.message);
+						});
+					}
+				} catch (e: any) {
+					this.#errorHandler?.(e.message);
+				}
 			}
 		}
 
@@ -71,27 +98,27 @@ export class LiteEmit<EM extends EventMap = EventMap> {
 		listener?: Listener<EM[K]> | WildcardListener<EM>,
 	): this {
 		if (event === undefined) {
-			this.listenerMap.clear();
-			this.wildcardListeners.clear();
+			this.#listenerMap.clear();
+			this.#wildcardListeners.clear();
 
 			return this;
 			// Event param is given
 		} else if (event === "*") {
 			// Remove the specified listener
 			if (listener) {
-				this.wildcardListeners.delete(listener as WildcardListener<EM>);
+				this.#wildcardListeners.delete(listener as WildcardListener<EM>);
 				// Clear all wildcard listners
 			} else {
-				this.wildcardListeners.clear();
+				this.#wildcardListeners.clear();
 			}
 
 			return this;
 		}
 		// The event param is defined and not a wildcard symbol
 		if (listener) {
-			this.listenerMap.get(event)?.delete(listener as any);
+			this.#listenerMap.get(event)?.delete(listener as any);
 		} else {
-			this.listenerMap.get(event)?.clear();
+			this.#listenerMap.get(event)?.clear();
 		}
 
 		return this;

test/index.test.ts

@@ -8,9 +8,15 @@ type EventMap = {
 	bar: ["bar", number, symbol];
 	baz: [42];
 	faq: [];
+	error: [];
+	error2: [];
 };
 
-const emitter = new LiteEmit<EventMap>();
+const errorMsgs: string[] = [];
+
+const emitter = new LiteEmit<EventMap>({
+	errorHandler: (s) => errorMsgs.push(s),
+});
 
 const Sym = Symbol("d");
 
@@ -120,4 +126,27 @@ describe("should", () => {
 
 		expect(count2).toBe(3);
 	});
+
+	it("errorHandler", () => {
+		emitter
+			.on("error", () => {
+				throw new Error("Foo");
+			})
+			.emit("error");
+
+		expect(errorMsgs[0]).toBe("Foo");
+	});
+
+	it("errorHandler async", () => {
+		emitter
+			.on("error2", async () => {
+				throw new Error("Bar");
+			})
+			.emit("error2");
+
+		// Wait for async action
+		setTimeout(() => {
+			expect(errorMsgs[1]).toBe("Bar");
+		}, 500);
+	});
 });