@bernierllc/event-emitter 1.0.1

package/src/event-emitter.ts

@@ -0,0 +1,190 @@
+/*
+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

@@ -0,0 +1,17 @@
+/*
+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

@@ -0,0 +1,11 @@
+/*
+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

@@ -0,0 +1,46 @@
+/*
+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

@@ -0,0 +1,22 @@
+{
+  "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__"]
+}