@bernierllc/event-emitter 1.0.8 → 1.2.0

package/__tests__/logger-integration.test.ts

@@ -1,132 +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 - Logger Integration', () => {
-  describe('with logger enabled', () => {
-    it('should log events when logEvents is true', async () => {
-      const emitter = new EventEmitter({ logEvents: true });
-
-      const handler = jest.fn();
-      emitter.on('test', handler);
-
-      await emitter.emit('test', { data: 'test' });
-
-      expect(handler).toHaveBeenCalledWith({ data: 'test' });
-    });
-
-    it('should log listener additions', () => {
-      const emitter = new EventEmitter({ logEvents: true });
-
-      const handler = jest.fn();
-      const subscription = emitter.on('user.created', handler);
-
-      expect(subscription).toBeDefined();
-      expect(subscription.eventType).toBe('user.created');
-    });
-
-    it('should log listener removals', () => {
-      const emitter = new EventEmitter({ logEvents: true });
-
-      const handler = jest.fn();
-      const subscription = emitter.on('test', handler);
-
-      emitter.off(subscription);
-      expect(emitter.listenerCount('test')).toBe(0);
-    });
-
-    it('should log removeAllListeners operations', () => {
-      const emitter = new EventEmitter({ logEvents: true });
-
-      emitter.on('test1', jest.fn());
-      emitter.on('test2', jest.fn());
-
-      emitter.removeAllListeners('test1');
-      expect(emitter.listenerCount('test1')).toBe(0);
-      expect(emitter.listenerCount('test2')).toBe(1);
-    });
-
-    it('should log removeAllListeners for all events', () => {
-      const emitter = new EventEmitter({ logEvents: true });
-
-      emitter.on('test1', jest.fn());
-      emitter.on('test2', jest.fn());
-
-      emitter.removeAllListeners();
-      expect(emitter.listenerCount('test1')).toBe(0);
-      expect(emitter.listenerCount('test2')).toBe(0);
-    });
-
-    it('should log handler errors when captureErrors is true', async () => {
-      const emitter = new EventEmitter({ logEvents: true, captureErrors: true });
-
-      const errorHandler = jest.fn(() => {
-        throw new Error('Test error');
-      });
-
-      emitter.on('test', errorHandler);
-      await emitter.emit('test', {});
-
-      expect(errorHandler).toHaveBeenCalled();
-    });
-  });
-
-  describe('without logger', () => {
-    it('should work without logger when logEvents is false', async () => {
-      const emitter = new EventEmitter({ logEvents: false });
-
-      const handler = jest.fn();
-      emitter.on('test', handler);
-
-      await emitter.emit('test', { data: 'test' });
-
-      expect(handler).toHaveBeenCalledWith({ data: 'test' });
-    });
-
-    it('should not attempt logging when logger unavailable', async () => {
-      // Logger is optional, so this should work fine
-      const emitter = new EventEmitter({ logEvents: true });
-
-      const handler = jest.fn();
-      emitter.on('test', handler);
-
-      await expect(emitter.emit('test', {})).resolves.toBeUndefined();
-      expect(handler).toHaveBeenCalled();
-    });
-  });
-
-  describe('error logging', () => {
-    it('should handle errors without logger when captureErrors is true', async () => {
-      const emitter = new EventEmitter({ captureErrors: true, logEvents: false });
-
-      const handler = jest.fn(() => {
-        throw new Error('Handler error');
-      });
-
-      emitter.on('test', handler);
-
-      // Should not throw despite error in handler
-      await expect(emitter.emit('test', {})).resolves.toBeUndefined();
-    });
-
-    it('should log errors with subscription ID when available', async () => {
-      const emitter = new EventEmitter({ logEvents: true, captureErrors: true });
-
-      const handler = jest.fn(() => {
-        throw new Error('Handler error with ID');
-      });
-
-      const subscription = emitter.on('test', handler);
-
-      await emitter.emit('test', {});
-
-      expect(subscription.id).toBeDefined();
-    });
-  });
-});

package/__tests__/wildcard.test.ts

@@ -1,151 +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 - Wildcard Listeners', () => {
-  let emitter: EventEmitter;
-
-  beforeEach(() => {
-    emitter = new EventEmitter();
-  });
-
-  describe('wildcard subscription', () => {
-    it('should add wildcard listener', () => {
-      const handler = jest.fn();
-      const subscription = emitter.on('*', handler);
-
-      expect(subscription.eventType).toBe('*');
-      expect(emitter.listenerCount('*')).toBe(1);
-    });
-
-    it('should call wildcard listener for any event', async () => {
-      const wildcardHandler = jest.fn();
-      emitter.on('*', wildcardHandler);
-
-      await emitter.emit('event1', { data: 'test1' });
-      await emitter.emit('event2', { data: 'test2' });
-      await emitter.emit('event3', { data: 'test3' });
-
-      expect(wildcardHandler).toHaveBeenCalledTimes(3);
-      expect(wildcardHandler).toHaveBeenCalledWith({ data: 'test1' });
-      expect(wildcardHandler).toHaveBeenCalledWith({ data: 'test2' });
-      expect(wildcardHandler).toHaveBeenCalledWith({ data: 'test3' });
-    });
-
-    it('should call both wildcard and specific listeners', async () => {
-      const wildcardHandler = jest.fn();
-      const specificHandler = jest.fn();
-
-      emitter.on('*', wildcardHandler);
-      emitter.on('test', specificHandler);
-
-      await emitter.emit('test', { data: 'test' });
-
-      expect(wildcardHandler).toHaveBeenCalledTimes(1);
-      expect(specificHandler).toHaveBeenCalledTimes(1);
-    });
-
-    it('should handle multiple wildcard listeners', async () => {
-      const handler1 = jest.fn();
-      const handler2 = jest.fn();
-      const handler3 = jest.fn();
-
-      emitter.on('*', handler1);
-      emitter.on('*', handler2);
-      emitter.on('*', handler3);
-
-      await emitter.emit('test', { data: 'test' });
-
-      expect(handler1).toHaveBeenCalledTimes(1);
-      expect(handler2).toHaveBeenCalledTimes(1);
-      expect(handler3).toHaveBeenCalledTimes(1);
-    });
-
-    it('should remove wildcard listener', () => {
-      const handler = jest.fn();
-      const subscription = emitter.on('*', handler);
-
-      expect(emitter.listenerCount('*')).toBe(1);
-
-      emitter.off(subscription);
-      expect(emitter.listenerCount('*')).toBe(0);
-    });
-
-    it('should support wildcard once listeners', async () => {
-      const handler = jest.fn();
-      emitter.once('*', handler);
-
-      await emitter.emit('event1', { data: 'test1' });
-      await emitter.emit('event2', { data: 'test2' });
-
-      expect(handler).toHaveBeenCalledTimes(1);
-      expect(handler).toHaveBeenCalledWith({ data: 'test1' });
-    });
-
-    it('should remove all wildcard listeners', () => {
-      emitter.on('*', jest.fn());
-      emitter.on('*', jest.fn());
-
-      expect(emitter.listenerCount('*')).toBe(2);
-
-      emitter.removeAllListeners('*');
-      expect(emitter.listenerCount('*')).toBe(0);
-    });
-
-    it('should remove wildcard listeners when removing all', () => {
-      emitter.on('*', jest.fn());
-      emitter.on('test', jest.fn());
-
-      emitter.removeAllListeners();
-
-      expect(emitter.listenerCount('*')).toBe(0);
-      expect(emitter.listenerCount('test')).toBe(0);
-    });
-  });
-
-  describe('wildcard listener edge cases', () => {
-    it('should handle wildcard with no other listeners', async () => {
-      const handler = jest.fn();
-      emitter.on('*', handler);
-
-      await emitter.emit('test', { data: 'test' });
-
-      expect(handler).toHaveBeenCalledTimes(1);
-    });
-
-    it('should not affect specific listeners when removing wildcard', async () => {
-      const wildcardHandler = jest.fn();
-      const specificHandler = jest.fn();
-
-      const wildcardSub = emitter.on('*', wildcardHandler);
-      emitter.on('test', specificHandler);
-
-      emitter.off(wildcardSub);
-
-      await emitter.emit('test', { data: 'test' });
-
-      expect(wildcardHandler).not.toHaveBeenCalled();
-      expect(specificHandler).toHaveBeenCalledTimes(1);
-    });
-
-    it('should handle mixed wildcard and specific once listeners', async () => {
-      const wildcardHandler = jest.fn();
-      const specificHandler = jest.fn();
-
-      emitter.once('*', wildcardHandler);
-      emitter.once('test', specificHandler);
-
-      await emitter.emit('test', { data: 'test' });
-      await emitter.emit('test', { data: 'test2' });
-
-      expect(wildcardHandler).toHaveBeenCalledTimes(1);
-      expect(specificHandler).toHaveBeenCalledTimes(1);
-    });
-  });
-});

package/jest.config.cjs

@@ -1,30 +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.
-*/
-
-module.exports = {
-  preset: 'ts-jest',
-  // Use fixed environment to handle Node.js v25+ localStorage issue
-  testEnvironment: '<rootDir>/../../../jest-environment-node-fixed.cjs',
-  roots: ['<rootDir>/__tests__'],
-  testMatch: ['**/*.test.ts'],
-  collectCoverageFrom: [
-    'src/**/*.ts',
-    '!src/**/*.d.ts',
-    '!src/index.ts'
-  ],
-  coverageThreshold: {
-    global: {
-      branches: 90,
-      functions: 90,
-      lines: 90,
-      statements: 90
-    }
-  },
-  coverageDirectory: 'coverage',
-  verbose: true
-};

package/src/event-emitter.ts

@@ -1,190 +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 { EventHandler, EventSubscription, EventEmitterOptions } from './types';
-
-/**
- * Event bus for inter-package communication
- */
-export class EventEmitter {
-  private listeners: Map<string, Set<EventSubscription>>;
-  private wildcardListeners: Set<EventSubscription>;
-  private options: Required<EventEmitterOptions>;
-  private logger?: any;
-
-  constructor(options: EventEmitterOptions = {}) {
-    this.listeners = new Map();
-    this.wildcardListeners = new Set();
-    this.options = {
-      maxListeners: options.maxListeners || 0,
-      logEvents: options.logEvents || false,
-      captureErrors: options.captureErrors !== false // Default to true
-    };
-
-    // Try to load logger if available
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-var-requires
-      const { createLogger } = require('@bernierllc/logger');
-      this.logger = createLogger({ level: 'debug' });
-    } catch {
-      // Logger not available, continue without it
-    }
-  }
-
-  /**
-   * Subscribe to event
-   */
-  on<T = any>(eventType: string, handler: EventHandler<T>): EventSubscription {
-    // Check max listeners
-    if (this.options.maxListeners > 0) {
-      const currentCount = this.listenerCount(eventType);
-      if (currentCount >= this.options.maxListeners) {
-        throw new Error(`Max listeners (${this.options.maxListeners}) exceeded for event type: ${eventType}`);
-      }
-    }
-
-    const subscription: EventSubscription = {
-      id: `${eventType}-${Date.now()}-${Math.random()}`,
-      eventType,
-      handler,
-      once: false,
-      unsubscribe: () => this.off(subscription)
-    };
-
-    if (eventType === '*') {
-      this.wildcardListeners.add(subscription);
-    } else {
-      if (!this.listeners.has(eventType)) {
-        this.listeners.set(eventType, new Set());
-      }
-      this.listeners.get(eventType)!.add(subscription);
-    }
-
-    if (this.options.logEvents && this.logger) {
-      this.logger.debug('Event listener added', { eventType, subscriptionId: subscription.id });
-    }
-
-    return subscription;
-  }
-
-  /**
-   * Subscribe to event once
-   */
-  once<T = any>(eventType: string, handler: EventHandler<T>): EventSubscription {
-    const subscription = this.on(eventType, handler);
-    subscription.once = true;
-    return subscription;
-  }
-
-  /**
-   * Unsubscribe from event
-   */
-  off(subscription: EventSubscription): void {
-    if (subscription.eventType === '*') {
-      this.wildcardListeners.delete(subscription);
-    } else {
-      const listeners = this.listeners.get(subscription.eventType);
-      if (listeners) {
-        listeners.delete(subscription);
-        // Clean up empty sets
-        if (listeners.size === 0) {
-          this.listeners.delete(subscription.eventType);
-        }
-      }
-    }
-
-    if (this.options.logEvents && this.logger) {
-      this.logger.debug('Event listener removed', {
-        eventType: subscription.eventType,
-        subscriptionId: subscription.id
-      });
-    }
-  }
-
-  /**
-   * Publish event
-   */
-  async emit<T = any>(eventType: string, data: T): Promise<void> {
-    if (this.options.logEvents && this.logger) {
-      this.logger.debug('Event emitted', { eventType, data });
-    }
-
-    // Get specific listeners
-    const specificListeners = this.listeners.get(eventType) || new Set();
-
-    // Combine with wildcard listeners
-    const allListeners = [...specificListeners, ...this.wildcardListeners];
-
-    // Execute handlers
-    const promises = allListeners.map(async (subscription) => {
-      try {
-        await subscription.handler(data);
-      } catch (error) {
-        if (this.options.captureErrors) {
-          if (this.logger) {
-            this.logger.error('Event handler error', {
-              eventType,
-              subscriptionId: subscription.id,
-              error: error instanceof Error ? error.message : String(error)
-            });
-          }
-        } else {
-          throw error;
-        }
-      } finally {
-        // Remove if once subscription (always happens, even if error occurred)
-        if (subscription.once) {
-          this.off(subscription);
-        }
-      }
-    });
-
-    await Promise.all(promises);
-  }
-
-  /**
-   * Remove all listeners for event type
-   */
-  removeAllListeners(eventType?: string): void {
-    if (eventType) {
-      if (eventType === '*') {
-        this.wildcardListeners.clear();
-      } else {
-        this.listeners.delete(eventType);
-      }
-    } else {
-      this.listeners.clear();
-      this.wildcardListeners.clear();
-    }
-
-    if (this.options.logEvents && this.logger) {
-      this.logger.debug('Listeners removed', { eventType: eventType || 'all' });
-    }
-  }
-
-  /**
-   * Get listener count for event type
-   */
-  listenerCount(eventType: string): number {
-    if (eventType === '*') {
-      return this.wildcardListeners.size;
-    }
-    return this.listeners.get(eventType)?.size || 0;
-  }
-
-  /**
-   * Get all event types with listeners
-   */
-  eventNames(): string[] {
-    const names = Array.from(this.listeners.keys());
-    if (this.wildcardListeners.size > 0) {
-      names.push('*');
-    }
-    return names;
-  }
-}

package/src/factory.ts

@@ -1,17 +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 './event-emitter';
-import { EventEmitterOptions } from './types';
-
-/**
- * Factory function for creating event emitters
- */
-export function createEventEmitter(options?: EventEmitterOptions): EventEmitter {
-  return new EventEmitter(options);
-}

package/src/index.ts

@@ -1,11 +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.
-*/
-
-export { EventEmitter } from './event-emitter';
-export { createEventEmitter } from './factory';
-export type { EventHandler, EventSubscription, EventEmitterOptions } from './types';

package/src/types.ts

@@ -1,46 +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.
-*/
-
-/**
- * Event handler function
- */
-export type EventHandler<T = any> = (data: T) => void | Promise<void>;
-
-/**
- * Event subscription
- */
-export interface EventSubscription {
-  /** Unique subscription ID */
-  id: string;
-
-  /** Event type */
-  eventType: string;
-
-  /** Handler function */
-  handler: EventHandler;
-
-  /** Whether this is a one-time subscription */
-  once: boolean;
-
-  /** Unsubscribe function */
-  unsubscribe: () => void;
-}
-
-/**
- * Event emitter options
- */
-export interface EventEmitterOptions {
-  /** Maximum listeners per event (0 = unlimited) */
-  maxListeners?: number;
-
-  /** Whether to log events */
-  logEvents?: boolean;
-
-  /** Whether to capture errors */
-  captureErrors?: boolean;
-}

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "lib": ["ES2020"],
-    "declaration": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "__tests__"]
-}