Event Listener Manager

Build an event listener manager that provides a unified interface for batch adding and removing event handlers with support for both named events and pattern-based event groups.

Requirements

Implement a ListenerManager class that wraps an EventEmitter instance and provides methods to:

1. Batch register multiple listeners to one or more events in a single operation
2. Batch remove multiple listeners from one or more events in a single operation
3. Support both string-based event names and regular expression patterns for event matching
4. Track which events have been defined for pattern matching purposes

The manager should handle the complexity of listener manipulation while providing a clean, simple API for users.

Capabilities

Batch Listener Registration

The manager supports adding multiple listeners to events in a single call.

• Creating a manager with an emitter, calling batchAdd('data', [fn1, fn2, fn3]), then emitting 'data' with value 'test' causes all three functions to execute with 'test' @test
• Creating a manager with an emitter, defining events ['user.login', 'user.logout'], calling batchAdd(/user\..*/, handlerFn), then emitting both 'user.login' and 'user.logout' causes handlerFn to execute for both events @test

Batch Listener Removal

The manager supports removing multiple listeners from events in a single call.

• After batch adding three listeners to 'data', calling batchRemove('data', [fn1, fn2]) removes those two listeners, and emitting 'data' only triggers fn3 @test
• After batch adding a listener to events matching /user..*/, calling batchRemove(/user\..*/, handlerFn) removes the listener from all matching events, and emitting those events no longer triggers the handler @test

Implementation

@generates

API

/**
 * ListenerManager wraps an EventEmitter to provide batch listener operations
 */
class ListenerManager {
  /**
   * Creates a new ListenerManager
   * @param {EventEmitter} emitter - The EventEmitter instance to manage
   */
  constructor(emitter) {}

  /**
   * Batch add listeners to an event or events
   * @param {string|RegExp} event - Event name or pattern
   * @param {Function|Function[]} listeners - Single listener or array of listeners
   * @returns {ListenerManager} - Returns this for chaining
   */
  batchAdd(event, listeners) {}

  /**
   * Batch remove listeners from an event or events
   * @param {string|RegExp} event - Event name or pattern
   * @param {Function|Function[]} listeners - Single listener or array of listeners
   * @returns {ListenerManager} - Returns this for chaining
   */
  batchRemove(event, listeners) {}

  /**
   * Define events for pattern matching support
   * @param {string[]} eventNames - Array of event names to define
   * @returns {ListenerManager} - Returns this for chaining
   */
  defineEvents(eventNames) {}

  /**
   * Get the underlying EventEmitter instance
   * @returns {EventEmitter}
   */
  getEmitter() {}
}

module.exports = ListenerManager;

Dependencies { .dependencies }

wolfy87-eventemitter { .dependency }

Provides the underlying event emitter functionality with support for listener manipulation.