fix: async emitter

src/emitters/ReadonlyEmitterBase.ts

@@ -35,7 +35,7 @@ export abstract class ReadonlyEmitterBase<EventMap> implements ReadonlyEmitter<E
     order?: number,
   ): this {
     if (!listener[ONCE]) {
-      this._log.trace(__LISTENERS(listener), `on(${String(type)})`);
+      this._log.trace(__LISTENERS(listener), 'on(%s)', type);
     }
 
     if (!this._listeners.has(type)) {
@@ -50,7 +50,7 @@ export abstract class ReadonlyEmitterBase<EventMap> implements ReadonlyEmitter<E
   }
 
   once<K extends keyof EventMap>(type: K | '*', listener: Function, order?: number): this {
-    this._log.trace(__LISTENERS(listener), `once(${String(type)})`);
+    this._log.trace(__LISTENERS(listener), 'once(%s)', type);
     return this.on(type, this.#createOnceListener(type, listener), order);
   }
 
@@ -60,7 +60,7 @@ export abstract class ReadonlyEmitterBase<EventMap> implements ReadonlyEmitter<E
     _order?: number,
   ): this {
     if (!listener[ONCE]) {
-      this._log.trace(__LISTENERS(listener), `off(${String(type)})`);
+      this._log.trace(__LISTENERS(listener), 'off(%s)', type);
     }
 
     const listeners = this._listeners.get(type) || [];

src/emitters/SerialAsyncEmitter.test.ts

@@ -1,3 +1,4 @@
+jest.mock('./logError');
 import { SerialAsyncEmitter } from './SerialAsyncEmitter';
 
 describe('SerialAsyncEmitter', () => {
@@ -50,22 +51,28 @@ describe('SerialAsyncEmitter', () => {
 
   it('should not delay emits within emits', async () => {
     const emitter = new SerialAsyncEmitter<TestEventMap>('test-emitter');
-    const listener1 = jest.fn(() => emitter.emit('test', { type: 'test', payload: 84 }));
+    const listener1 = jest.fn(() => {
+      emitter.emit('test', { type: 'test', payload: 84 });
+    });
     const listener2 = jest.fn();
     emitter.once('test', listener1);
     emitter.on('test', listener2);
     await emitter.emit('test', { type: 'test', payload: 42 });
-    expect(listener2).toHaveBeenCalledTimes(1);
+    expect(listener1).toHaveBeenCalledTimes(1);
+    expect(listener2).toHaveBeenCalledTimes(2);
   });
 
   it('should tolerate errors in listeners', async () => {
+    const error = new Error('This listener failed');
     const emitter = new SerialAsyncEmitter<TestEventMap>('test-emitter');
-    const listener1 = jest.fn().mockRejectedValue(new Error('This listener failed'));
+    const listener1 = () => Promise.reject(error);
     const listener2 = jest.fn();
     emitter.once('test', listener1);
     emitter.once('test', listener2);
     await emitter.emit('test', { type: 'test', payload: 42 });
     expect(listener2).toHaveBeenCalledTimes(1);
+    const { logError } = jest.requireMock('./logError');
+    expect(logError).toHaveBeenCalledWith(error, 'test', expect.any(Function));
   });
 });
 

src/emitters/SerialAsyncEmitter.ts

@@ -1,3 +1,4 @@
+import { arraysEqual } from '../utils';
 import type { AsyncEmitter } from './AsyncEmitter';
 import { logError } from './logError';
 import { ReadonlyEmitterBase } from './ReadonlyEmitterBase';
@@ -7,14 +8,24 @@ export class SerialAsyncEmitter<EventMap>
   extends ReadonlyEmitterBase<EventMap>
   implements AsyncEmitter<EventMap>
 {
-  #promise = Promise.resolve();
+  #tasks: Promise<void>[] = [];
+  #idle?: Promise<void>;
 
   emit<K extends keyof EventMap>(eventType: K, event: EventMap[K]): Promise<void> {
-    return this.#enqueue(eventType, event);
+    this.#tasks.push(this.#doEmit(eventType, event));
+    this.#idle ??= this.#waitForIdle();
+    return this.#idle;
   }
 
-  #enqueue<K extends keyof EventMap>(eventType: K, event: EventMap[K]) {
-    return (this.#promise = this.#promise.then(() => this.#doEmit(eventType, event)));
+  async #waitForIdle() {
+    let $promises: Promise<void>[] = [];
+    while (!arraysEqual($promises, this.#tasks)) {
+      $promises = [...this.#tasks];
+      await Promise.all($promises);
+    }
+
+    this.#tasks.splice(0, this.#tasks.length);
+    this.#idle = undefined;
   }
 
   async #doEmit<K extends keyof EventMap>(eventType: K, event: EventMap[K]) {

src/emitters/logError.ts

@@ -1,9 +1,10 @@
 import { logger } from '../utils';
 
-// eslint-disable-next-line @typescript-eslint/ban-types
-export function logError(error: unknown, eventType: string, listener: Function) {
-  const errorDetails = (error instanceof Error && error.stack) || String(error);
+export function logError(error: unknown, eventType: unknown, listener: unknown) {
   logger.warn(
-    `Caught an error while emitting "${eventType}" event:\n${errorDetails}\nThe listener function was:\n${listener}`,
+    error,
+    `Caught an error while emitting %j event in a listener function:\n%s`,
+    eventType,
+    listener,
   );
 }

src/utils/arraysEqual.test.ts

@@ -0,0 +1,33 @@
+import { arraysEqual } from './arraysEqual';
+
+const EMPTY_OBJECT = {};
+const EMPTY_ARRAY: unknown[] = [];
+const FUNCTION = () => {};
+const STRING = 'string';
+const NUMBER = 123;
+const BOOLEAN = true;
+const ARRAY = [EMPTY_OBJECT, EMPTY_ARRAY, FUNCTION, STRING, NUMBER, BOOLEAN];
+
+describe('arraysEqual', () => {
+  it('should return true for empty arrays', () => {
+    expect(arraysEqual([], [])).toBe(true);
+  });
+
+  it('should return true for the same array', () => {
+    expect(arraysEqual(ARRAY, ARRAY)).toBe(true);
+  });
+
+  it('should return true for arrays with the same elements', () => {
+    expect(arraysEqual([...ARRAY], [...ARRAY])).toBe(true);
+  });
+
+  it('should return false for arrays with different lengths', () => {
+    const arr1 = Array.from({ length: 1 });
+    const arr2 = Array.from({ length: 2 });
+    expect(arraysEqual(arr1, arr2)).toBe(false);
+  });
+
+  it('should return false for arrays with different elements', () => {
+    expect(arraysEqual([{}], [{}])).toBe(false);
+  });
+});

src/utils/arraysEqual.ts

@@ -0,0 +1,12 @@
+/* eslint-disable unicorn/no-for-loop */
+export function arraysEqual<T>(a: readonly T[], b: readonly T[]): boolean {
+  if (a === b) return true;
+
+  if (a.length !== b.length) return false;
+
+  const length = a.length;
+  for (let index = 0; index < length; index++) {
+    if (a[index] !== b[index]) return false;
+  }
+  return true;
+}

src/utils/index.ts

@@ -1,3 +1,4 @@
+export * from './arraysEqual';
 export * from './assertions';
 export * from './getHierarchy';
 export * from './iterateSorted';