@bernierllc/event-emitter 1.0.8 → 1.2.0

package/__tests__/error-handling.test.ts

@@ -1,310 +0,0 @@
-/*
-Copyright (c) 2025 Bernier LLC
-
-This file is licensed to the client under a limited-use license.
-The client may use and modify this code *only within the scope of the project it was delivered for*.
-Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
-*/
-
-import { EventEmitter } from '../src';
-
-describe('EventEmitter - Error Handling', () => {
-  let emitter: EventEmitter;
-
-  beforeEach(() => {
-    emitter = new EventEmitter();
-  });
-
-  describe('handler error handling with captureErrors enabled', () => {
-    beforeEach(() => {
-      emitter = new EventEmitter({ captureErrors: true });
-    });
-
-    it('should capture and suppress handler errors', async () => {
-      const errorHandler = jest.fn(() => {
-        throw new Error('Handler error');
-      });
-
-      const successHandler = jest.fn();
-
-      emitter.on('test', errorHandler);
-      emitter.on('test', successHandler);
-
-      await expect(emitter.emit('test', {})).resolves.toBeUndefined();
-
-      expect(errorHandler).toHaveBeenCalled();
-      expect(successHandler).toHaveBeenCalled();
-    });
-
-    it('should continue executing other handlers after error', async () => {
-      const handler1 = jest.fn(() => {
-        throw new Error('Error in handler 1');
-      });
-      const handler2 = jest.fn();
-      const handler3 = jest.fn(() => {
-        throw new Error('Error in handler 3');
-      });
-      const handler4 = jest.fn();
-
-      emitter.on('test', handler1);
-      emitter.on('test', handler2);
-      emitter.on('test', handler3);
-      emitter.on('test', handler4);
-
-      await emitter.emit('test', {});
-
-      expect(handler1).toHaveBeenCalled();
-      expect(handler2).toHaveBeenCalled();
-      expect(handler3).toHaveBeenCalled();
-      expect(handler4).toHaveBeenCalled();
-    });
-
-    it('should capture async handler errors', async () => {
-      const asyncErrorHandler = jest.fn(async () => {
-        await new Promise(resolve => setTimeout(resolve, 10));
-        throw new Error('Async error');
-      });
-
-      const successHandler = jest.fn();
-
-      emitter.on('test', asyncErrorHandler);
-      emitter.on('test', successHandler);
-
-      await expect(emitter.emit('test', {})).resolves.toBeUndefined();
-
-      expect(asyncErrorHandler).toHaveBeenCalled();
-      expect(successHandler).toHaveBeenCalled();
-    });
-
-    it('should handle errors in wildcard listeners', async () => {
-      const wildcardError = jest.fn(() => {
-        throw new Error('Wildcard error');
-      });
-
-      const specificHandler = jest.fn();
-
-      emitter.on('*', wildcardError);
-      emitter.on('test', specificHandler);
-
-      await expect(emitter.emit('test', {})).resolves.toBeUndefined();
-
-      expect(wildcardError).toHaveBeenCalled();
-      expect(specificHandler).toHaveBeenCalled();
-    });
-
-    it('should handle errors in once listeners', async () => {
-      const onceError = jest.fn(() => {
-        throw new Error('Once error');
-      });
-
-      emitter.once('test', onceError);
-
-      await expect(emitter.emit('test', {})).resolves.toBeUndefined();
-
-      expect(onceError).toHaveBeenCalled();
-      expect(emitter.listenerCount('test')).toBe(0);
-    });
-  });
-
-  describe('handler error handling with captureErrors disabled', () => {
-    beforeEach(() => {
-      emitter = new EventEmitter({ captureErrors: false });
-    });
-
-    it('should throw handler errors when captureErrors is false', async () => {
-      const errorHandler = jest.fn(() => {
-        throw new Error('Handler error');
-      });
-
-      emitter.on('test', errorHandler);
-
-      await expect(emitter.emit('test', {})).rejects.toThrow('Handler error');
-    });
-
-    it('should throw async handler errors when captureErrors is false', async () => {
-      const asyncErrorHandler = jest.fn(async () => {
-        await new Promise(resolve => setTimeout(resolve, 10));
-        throw new Error('Async handler error');
-      });
-
-      emitter.on('test', asyncErrorHandler);
-
-      await expect(emitter.emit('test', {})).rejects.toThrow('Async handler error');
-    });
-
-    it('should throw first error when multiple handlers fail', async () => {
-      const handler1 = jest.fn(async () => {
-        await new Promise(resolve => setTimeout(resolve, 20));
-        throw new Error('Error 1');
-      });
-
-      const handler2 = jest.fn(async () => {
-        await new Promise(resolve => setTimeout(resolve, 10));
-        throw new Error('Error 2');
-      });
-
-      emitter.on('test', handler1);
-      emitter.on('test', handler2);
-
-      // With Promise.all, the first rejection is thrown
-      await expect(emitter.emit('test', {})).rejects.toThrow();
-    });
-  });
-
-  describe('error types', () => {
-    beforeEach(() => {
-      emitter = new EventEmitter({ captureErrors: true });
-    });
-
-    it('should handle Error objects', async () => {
-      const handler = jest.fn(() => {
-        throw new Error('Standard error');
-      });
-
-      emitter.on('test', handler);
-      await expect(emitter.emit('test', {})).resolves.toBeUndefined();
-    });
-
-    it('should handle string errors', async () => {
-      const handler = jest.fn(() => {
-        throw 'String error';
-      });
-
-      emitter.on('test', handler);
-      await expect(emitter.emit('test', {})).resolves.toBeUndefined();
-    });
-
-    it('should handle custom error types', async () => {
-      class CustomError extends Error {
-        constructor(message: string, public code: number) {
-          super(message);
-        }
-      }
-
-      const handler = jest.fn(() => {
-        throw new CustomError('Custom error', 500);
-      });
-
-      emitter.on('test', handler);
-      await expect(emitter.emit('test', {})).resolves.toBeUndefined();
-    });
-
-    it('should handle null/undefined errors', async () => {
-      const handler1 = jest.fn(() => {
-        throw null;
-      });
-
-      const handler2 = jest.fn(() => {
-        throw undefined;
-      });
-
-      emitter.on('test1', handler1);
-      emitter.on('test2', handler2);
-
-      await expect(emitter.emit('test1', {})).resolves.toBeUndefined();
-      await expect(emitter.emit('test2', {})).resolves.toBeUndefined();
-    });
-  });
-
-  describe('error handling edge cases', () => {
-    it('should handle errors during listener removal', async () => {
-      const errorHandler = jest.fn(() => {
-        throw new Error('Handler error');
-      });
-
-      emitter.once('test', errorHandler);
-
-      // Error occurs but once listener should still be removed
-      await emitter.emit('test', {});
-
-      expect(emitter.listenerCount('test')).toBe(0);
-    });
-
-    it('should handle simultaneous errors from multiple listeners', async () => {
-      emitter = new EventEmitter({ captureErrors: true });
-
-      const error1 = jest.fn(() => {
-        throw new Error('Error 1');
-      });
-      const error2 = jest.fn(() => {
-        throw new Error('Error 2');
-      });
-      const error3 = jest.fn(() => {
-        throw new Error('Error 3');
-      });
-
-      emitter.on('test', error1);
-      emitter.on('test', error2);
-      emitter.on('test', error3);
-
-      await expect(emitter.emit('test', {})).resolves.toBeUndefined();
-
-      expect(error1).toHaveBeenCalled();
-      expect(error2).toHaveBeenCalled();
-      expect(error3).toHaveBeenCalled();
-    });
-
-    it('should handle errors in mix of sync and async handlers', async () => {
-      emitter = new EventEmitter({ captureErrors: true });
-
-      const syncError = jest.fn(() => {
-        throw new Error('Sync error');
-      });
-
-      const asyncError = jest.fn(async () => {
-        await new Promise(resolve => setTimeout(resolve, 10));
-        throw new Error('Async error');
-      });
-
-      const success = jest.fn();
-
-      emitter.on('test', syncError);
-      emitter.on('test', asyncError);
-      emitter.on('test', success);
-
-      await expect(emitter.emit('test', {})).resolves.toBeUndefined();
-
-      expect(syncError).toHaveBeenCalled();
-      expect(asyncError).toHaveBeenCalled();
-      expect(success).toHaveBeenCalled();
-    });
-  });
-
-  describe('error recovery', () => {
-    it('should allow re-emitting after error', async () => {
-      emitter = new EventEmitter({ captureErrors: true });
-
-      const handler = jest.fn((data: { shouldError: boolean }) => {
-        if (data.shouldError) {
-          throw new Error('Expected error');
-        }
-      });
-
-      emitter.on('test', handler);
-
-      // First emit with error
-      await emitter.emit('test', { shouldError: true });
-      expect(handler).toHaveBeenCalledTimes(1);
-
-      // Second emit without error
-      await emitter.emit('test', { shouldError: false });
-      expect(handler).toHaveBeenCalledTimes(2);
-    });
-
-    it('should maintain listeners after error', async () => {
-      emitter = new EventEmitter({ captureErrors: true });
-
-      const handler = jest.fn(() => {
-        throw new Error('Error');
-      });
-
-      emitter.on('test', handler);
-
-      await emitter.emit('test', {});
-      expect(emitter.listenerCount('test')).toBe(1);
-
-      await emitter.emit('test', {});
-      expect(emitter.listenerCount('test')).toBe(1);
-    });
-  });
-});

package/__tests__/event-emitter.test.ts

@@ -1,281 +0,0 @@
-/*
-Copyright (c) 2025 Bernier LLC
-
-This file is licensed to the client under a limited-use license.
-The client may use and modify this code *only within the scope of the project it was delivered for*.
-Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
-*/
-
-import { EventEmitter, createEventEmitter } from '../src';
-
-describe('EventEmitter', () => {
-  let emitter: EventEmitter;
-
-  beforeEach(() => {
-    emitter = new EventEmitter();
-  });
-
-  describe('constructor', () => {
-    it('should create event emitter with default options', () => {
-      expect(emitter).toBeInstanceOf(EventEmitter);
-      expect(emitter.listenerCount('test')).toBe(0);
-    });
-
-    it('should create event emitter with custom options', () => {
-      const customEmitter = new EventEmitter({
-        maxListeners: 10,
-        logEvents: true,
-        captureErrors: false
-      });
-      expect(customEmitter).toBeInstanceOf(EventEmitter);
-    });
-  });
-
-  describe('on', () => {
-    it('should add event listener', () => {
-      const handler = jest.fn();
-      const subscription = emitter.on('test', handler);
-
-      expect(subscription).toMatchObject({
-        eventType: 'test',
-        once: false
-      });
-      expect(subscription.id).toBeDefined();
-      expect(subscription.unsubscribe).toBeInstanceOf(Function);
-      expect(emitter.listenerCount('test')).toBe(1);
-    });
-
-    it('should add multiple listeners to same event', () => {
-      emitter.on('test', jest.fn());
-      emitter.on('test', jest.fn());
-      emitter.on('test', jest.fn());
-
-      expect(emitter.listenerCount('test')).toBe(3);
-    });
-
-    it('should enforce max listeners limit', () => {
-      const limitedEmitter = new EventEmitter({ maxListeners: 2 });
-
-      limitedEmitter.on('test', jest.fn());
-      limitedEmitter.on('test', jest.fn());
-
-      expect(() => {
-        limitedEmitter.on('test', jest.fn());
-      }).toThrow('Max listeners (2) exceeded for event type: test');
-    });
-
-    it('should allow unlimited listeners when maxListeners is 0', () => {
-      const unlimitedEmitter = new EventEmitter({ maxListeners: 0 });
-
-      for (let i = 0; i < 100; i++) {
-        unlimitedEmitter.on('test', jest.fn());
-      }
-
-      expect(unlimitedEmitter.listenerCount('test')).toBe(100);
-    });
-  });
-
-  describe('once', () => {
-    it('should add one-time listener', () => {
-      const handler = jest.fn();
-      const subscription = emitter.once('test', handler);
-
-      expect(subscription.once).toBe(true);
-      expect(emitter.listenerCount('test')).toBe(1);
-    });
-
-    it('should remove listener after first emission', async () => {
-      const handler = jest.fn();
-      emitter.once('test', handler);
-
-      await emitter.emit('test', { data: 'first' });
-      expect(handler).toHaveBeenCalledTimes(1);
-      expect(emitter.listenerCount('test')).toBe(0);
-
-      await emitter.emit('test', { data: 'second' });
-      expect(handler).toHaveBeenCalledTimes(1); // Still only called once
-    });
-  });
-
-  describe('off', () => {
-    it('should remove event listener', () => {
-      const handler = jest.fn();
-      const subscription = emitter.on('test', handler);
-
-      expect(emitter.listenerCount('test')).toBe(1);
-
-      emitter.off(subscription);
-      expect(emitter.listenerCount('test')).toBe(0);
-    });
-
-    it('should remove specific listener only', () => {
-      const handler1 = jest.fn();
-      const handler2 = jest.fn();
-      const sub1 = emitter.on('test', handler1);
-      emitter.on('test', handler2);
-
-      expect(emitter.listenerCount('test')).toBe(2);
-
-      emitter.off(sub1);
-      expect(emitter.listenerCount('test')).toBe(1);
-    });
-
-    it('should handle removing non-existent listener', () => {
-      const subscription = emitter.on('test', jest.fn());
-      emitter.off(subscription);
-
-      // Should not throw when removing again
-      expect(() => emitter.off(subscription)).not.toThrow();
-    });
-  });
-
-  describe('emit', () => {
-    it('should call event handler with data', async () => {
-      const handler = jest.fn();
-      emitter.on('test', handler);
-
-      await emitter.emit('test', { message: 'hello' });
-
-      expect(handler).toHaveBeenCalledTimes(1);
-      expect(handler).toHaveBeenCalledWith({ message: 'hello' });
-    });
-
-    it('should call multiple handlers for same event', async () => {
-      const handler1 = jest.fn();
-      const handler2 = jest.fn();
-      const handler3 = jest.fn();
-
-      emitter.on('test', handler1);
-      emitter.on('test', handler2);
-      emitter.on('test', handler3);
-
-      await emitter.emit('test', { data: 'test' });
-
-      expect(handler1).toHaveBeenCalledTimes(1);
-      expect(handler2).toHaveBeenCalledTimes(1);
-      expect(handler3).toHaveBeenCalledTimes(1);
-    });
-
-    it('should not call handlers for different event types', async () => {
-      const handler1 = jest.fn();
-      const handler2 = jest.fn();
-
-      emitter.on('event1', handler1);
-      emitter.on('event2', handler2);
-
-      await emitter.emit('event1', { data: 'test' });
-
-      expect(handler1).toHaveBeenCalledTimes(1);
-      expect(handler2).not.toHaveBeenCalled();
-    });
-
-    it('should handle emit with no listeners', async () => {
-      await expect(emitter.emit('nonexistent', { data: 'test' })).resolves.toBeUndefined();
-    });
-  });
-
-  describe('removeAllListeners', () => {
-    it('should remove all listeners for specific event type', () => {
-      emitter.on('test', jest.fn());
-      emitter.on('test', jest.fn());
-      emitter.on('other', jest.fn());
-
-      expect(emitter.listenerCount('test')).toBe(2);
-      expect(emitter.listenerCount('other')).toBe(1);
-
-      emitter.removeAllListeners('test');
-
-      expect(emitter.listenerCount('test')).toBe(0);
-      expect(emitter.listenerCount('other')).toBe(1);
-    });
-
-    it('should remove all listeners for all events', () => {
-      emitter.on('test1', jest.fn());
-      emitter.on('test2', jest.fn());
-      emitter.on('test3', jest.fn());
-
-      emitter.removeAllListeners();
-
-      expect(emitter.listenerCount('test1')).toBe(0);
-      expect(emitter.listenerCount('test2')).toBe(0);
-      expect(emitter.listenerCount('test3')).toBe(0);
-    });
-  });
-
-  describe('listenerCount', () => {
-    it('should return 0 for event with no listeners', () => {
-      expect(emitter.listenerCount('nonexistent')).toBe(0);
-    });
-
-    it('should return correct count for event with listeners', () => {
-      emitter.on('test', jest.fn());
-      emitter.on('test', jest.fn());
-
-      expect(emitter.listenerCount('test')).toBe(2);
-    });
-
-    it('should update count after adding/removing listeners', () => {
-      const sub1 = emitter.on('test', jest.fn());
-      const sub2 = emitter.on('test', jest.fn());
-
-      expect(emitter.listenerCount('test')).toBe(2);
-
-      emitter.off(sub1);
-      expect(emitter.listenerCount('test')).toBe(1);
-
-      emitter.off(sub2);
-      expect(emitter.listenerCount('test')).toBe(0);
-    });
-  });
-
-  describe('eventNames', () => {
-    it('should return empty array when no listeners', () => {
-      expect(emitter.eventNames()).toEqual([]);
-    });
-
-    it('should return array of event types', () => {
-      emitter.on('event1', jest.fn());
-      emitter.on('event2', jest.fn());
-      emitter.on('event3', jest.fn());
-
-      const names = emitter.eventNames();
-      expect(names).toContain('event1');
-      expect(names).toContain('event2');
-      expect(names).toContain('event3');
-    });
-
-    it('should include wildcard in event names', () => {
-      emitter.on('test', jest.fn());
-      emitter.on('*', jest.fn());
-
-      const names = emitter.eventNames();
-      expect(names).toContain('test');
-      expect(names).toContain('*');
-    });
-  });
-
-  describe('unsubscribe', () => {
-    it('should allow unsubscribing via subscription object', () => {
-      const handler = jest.fn();
-      const subscription = emitter.on('test', handler);
-
-      expect(emitter.listenerCount('test')).toBe(1);
-
-      subscription.unsubscribe();
-
-      expect(emitter.listenerCount('test')).toBe(0);
-    });
-  });
-
-  describe('factory function', () => {
-    it('should create event emitter via factory', () => {
-      const created = createEventEmitter();
-      expect(created).toBeInstanceOf(EventEmitter);
-    });
-
-    it('should pass options to factory', () => {
-      const created = createEventEmitter({ maxListeners: 5 });
-      expect(created).toBeInstanceOf(EventEmitter);
-    });
-  });
-});