### Install EventEmitter3

Source: https://github.com/primus/eventemitter3/blob/master/README.md

Install the eventemitter3 package using npm.

```bash
$ npm install --save eventemitter3
```

--------------------------------

### Require EventEmitter3

Source: https://github.com/primus/eventemitter3/blob/master/README.md

Require the eventemitter3 module after installation to create EventEmitter instances.

```javascript
var EventEmitter = require('eventemitter3');
```

--------------------------------

### Get Listeners with listeners()

Source: https://context7.com/primus/eventemitter3/llms.txt

Returns an array of listener functions registered for the given event. Returns an empty array if no listeners exist. The returned array is a copy, so modifications do not affect the emitter.

```javascript
const EventEmitter = require('eventemitter3');
const emitter = new EventEmitter();

function handleClick() {
  console.log('Clicked!');
}

function handleClickAlt() {
  console.log('Also clicked!');
}

// No listeners initially
console.log('Listeners (empty):', emitter.listeners('click'));  // Output: []

emitter.on('click', handleClick);
emitter.on('click', handleClickAlt);

const clickListeners = emitter.listeners('click');
console.log('Number of click listeners:', clickListeners.length);  // Output: 2
console.log('First listener:', clickListeners[0] === handleClick);  // Output: true
console.log('Second listener:', clickListeners[1] === handleClickAlt);  // Output: true

// The returned array is a copy, modifications don't affect the emitter
clickListeners.length = 0;
console.log('Actual listeners still exist:', emitter.listenerCount('click'));  // Output: 2
```

--------------------------------

### Include EventEmitter3 via CDN

Source: https://context7.com/primus/eventemitter3/llms.txt

Load the library directly in the browser using a script tag.

```html
<script src="https://unpkg.com/eventemitter3@latest/dist/eventemitter3.umd.min.js"></script>
```

--------------------------------

### Extend EventEmitter3 using inheritance patterns

Source: https://context7.com/primus/eventemitter3/llms.txt

Shows how to create custom event-emitting classes using both ES6 class syntax and the legacy Node.js util.inherits pattern.

```javascript
const EventEmitter = require('eventemitter3');
const util = require('util');

// ES6 Class inheritance
class MyEmitter extends EventEmitter {
  constructor() {
    super();
    this.value = 0;
  }

  increment() {
    this.value++;
    this.emit('changed', this.value);
  }
}

const counter = new MyEmitter();
counter.on('changed', (val) => console.log('Value changed to:', val));
counter.increment();  // Output: Value changed to: 1
counter.increment();  // Output: Value changed to: 2

// Node.js util.inherits pattern
function LegacyEmitter() {
  EventEmitter.call(this);
  this.status = 'ready';
}

util.inherits(LegacyEmitter, EventEmitter);

LegacyEmitter.prototype.setStatus = function(status) {
  this.status = status;
  this.emit('status', status);
};

const legacy = new LegacyEmitter();
legacy.on('status', (s) => console.log('Status:', s));
legacy.setStatus('active');  // Output: Status: active
```

--------------------------------

### Retrieve registered event names with eventNames()

Source: https://context7.com/primus/eventemitter3/llms.txt

Demonstrates how to list all registered event names, including support for string and Symbol keys.

```javascript
const EventEmitter = require('eventemitter3');
const emitter = new EventEmitter();

console.log('Initial events:', emitter.eventNames());  // Output: []

emitter.on('message', () => {});
emitter.on('error', () => {});
emitter.on('close', () => {});

console.log('Events:', emitter.eventNames());  // Output: ['message', 'error', 'close']

// Works with ES6 Symbols
const privateEvent = Symbol('private');
emitter.on(privateEvent, () => {});

const events = emitter.eventNames();
console.log('Includes symbol:', events.includes(privateEvent));  // Output: true

// Clean up and verify
emitter.removeAllListeners('message');
console.log('After removal:', emitter.eventNames());  // Output: ['error', 'close', Symbol(private)]
```

--------------------------------

### Inheritance Pattern

Source: https://context7.com/primus/eventemitter3/llms.txt

Demonstrates how to extend the EventEmitter3 class to create custom event-emitting objects using ES6 classes or Node.js util.inherits.

```APIDOC
## Inheritance Pattern

### Description
EventEmitter3 can be extended using class inheritance or Node.js util.inherits for creating custom event-emitting classes.
```

--------------------------------

### TypeScript Usage

Source: https://context7.com/primus/eventemitter3/llms.txt

Provides guidance on using EventEmitter3 with TypeScript, including defining event interfaces for type-safe listeners and emission.

```APIDOC
## TypeScript Usage

### Description
EventEmitter3 includes TypeScript definitions with full generic support for type-safe event handling.
```

--------------------------------

### Emit events with emit()

Source: https://context7.com/primus/eventemitter3/llms.txt

Triggers all listeners registered for a specific event, passing provided arguments to each.

```javascript
const EventEmitter = require('eventemitter3');
const emitter = new EventEmitter();

emitter.on('data', function(a, b, c) {
  console.log('Received:', a, b, c);
});

// Emit with multiple arguments
const hadListeners = emitter.emit('data', 'foo', 42, { key: 'value' });
console.log('Had listeners:', hadListeners);
// Output:
// Received: foo 42 { key: 'value' }
// Had listeners: true

// Emit event with no listeners
const result = emitter.emit('unknown-event', 'test');
console.log('Had listeners:', result);  // Output: Had listeners: false

// Multiple listeners receive the same arguments
emitter.on('message', (text) => console.log('Handler 1:', text));
emitter.on('message', (text) => console.log('Handler 2:', text));

emitter.emit('message', 'Hello!');
// Output:
// Handler 1: Hello!
// Handler 2: Hello!
```

--------------------------------

### Count Listeners with listenerCount()

Source: https://context7.com/primus/eventemitter3/llms.txt

Returns the number of listeners registered for a given event. This count decreases when a `once` listener is emitted.

```javascript
const EventEmitter = require('eventemitter3');
const emitter = new EventEmitter();

console.log('Initial count:', emitter.listenerCount('data'));  // Output: 0

emitter.on('data', () => {});
console.log('After one listener:', emitter.listenerCount('data'));  // Output: 1

emitter.on('data', () => {});
emitter.on('data', () => {});
console.log('After three listeners:', emitter.listenerCount('data'));  // Output: 3

emitter.once('data', () => {});
console.log('After once listener:', emitter.listenerCount('data'));  // Output: 4

emitter.emit('data');
console.log('After emit (once removed):', emitter.listenerCount('data'));  // Output: 3
```

--------------------------------

### listeners

Source: https://context7.com/primus/eventemitter3/llms.txt

Returns an array of listener functions registered for the given event. Returns an empty array if no listeners exist.

```APIDOC
## listeners(event)

### Description
Returns an array of listener functions registered for the given event. Returns an empty array if no listeners exist.

### Method
`listeners`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
const EventEmitter = require('eventemitter3');
const emitter = new EventEmitter();

function handleClick() { console.log('Clicked!'); }
emitter.on('click', handleClick);

const clickListeners = emitter.listeners('click');
console.log(clickListeners.length); // Output: 1
console.log(clickListeners[0] === handleClick); // Output: true
```

### Response
#### Success Response (200)
- **listeners** (Array) - An array of listener functions.

#### Response Example
```json
{
  "listeners": [
    "function handleClick() { console.log('Clicked!'); }"
  ]
}
```
```

--------------------------------

### EventEmitter3 - emit

Source: https://context7.com/primus/eventemitter3/llms.txt

Calls each listener registered for the event with the supplied arguments. Returns `true` if the event had listeners, `false` otherwise.

```APIDOC
## emit(event, ...args)

### Description
Calls each listener registered for the event with the supplied arguments. Returns `true` if the event had listeners, `false` otherwise.

### Method
POST

### Endpoint
/eventemitter3/emit

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **event** (string) - Required - The name of the event to emit.
- **args** (array) - Optional - An array of arguments to pass to the listeners.

### Request Example
```json
{
  "event": "data",
  "args": ["foo", 42, {"key": "value"}]
}
```

### Response
#### Success Response (200)
- **hadListeners** (boolean) - `true` if the event had listeners, `false` otherwise.

#### Response Example
```json
{
  "hadListeners": true
}
```
```

--------------------------------

### Register event listeners with on()

Source: https://context7.com/primus/eventemitter3/llms.txt

Adds a persistent listener to an event, optionally binding a custom context to avoid fn.bind() overhead.

```javascript
const EventEmitter = require('eventemitter3');
const emitter = new EventEmitter();

// Basic listener
emitter.on('message', function(data) {
  console.log('Received:', data);
});

// Listener with custom context
const handler = {
  name: 'MessageHandler',
  process: function(data) {
    console.log(`${this.name} received: ${data}`);
  }
};

emitter.on('message', handler.process, handler);

emitter.emit('message', 'Hello World');
// Output:
// Received: Hello World
// MessageHandler received: Hello World

// Method chaining
emitter
  .on('error', (err) => console.error('Error:', err.message))
  .on('data', (chunk) => console.log('Data:', chunk));
```

--------------------------------

### eventNames()

Source: https://context7.com/primus/eventemitter3/llms.txt

Retrieves an array of all event names currently registered with the emitter, including string and Symbol identifiers.

```APIDOC
## eventNames()

### Description
Returns an array of event names for which the emitter has registered listeners. Supports both string and Symbol event names.

### Response
- **Returns** (Array<string|Symbol>) - An array containing all event names that have active listeners.
```

--------------------------------

### Register one-time listeners with once()

Source: https://context7.com/primus/eventemitter3/llms.txt

Adds a listener that is automatically removed after the first time the event is emitted.

```javascript
const EventEmitter = require('eventemitter3');
const emitter = new EventEmitter();

let callCount = 0;

emitter.once('connect', function() {
  callCount++;
  console.log('Connected! Call count:', callCount);
});

emitter.emit('connect');  // Output: Connected! Call count: 1
emitter.emit('connect');  // No output - listener was removed
emitter.emit('connect');  // No output

console.log('Total calls:', callCount);  // Output: Total calls: 1
console.log('Listeners remaining:', emitter.listenerCount('connect'));  // Output: Listeners remaining: 0

// With context
const session = { id: 'abc123' };
emitter.once('authenticated', function(user) {
  console.log(`Session ${this.id} authenticated for ${user}`);
}, session);

emitter.emit('authenticated', 'john@example.com');
// Output: Session abc123 authenticated for john@example.com
```

--------------------------------

### listenerCount

Source: https://context7.com/primus/eventemitter3/llms.txt

Returns the number of listeners registered for a given event.

```APIDOC
## listenerCount(event)

### Description
Returns the number of listeners registered for a given event.

### Method
`listenerCount`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
const EventEmitter = require('eventemitter3');
const emitter = new EventEmitter();

emitter.on('data', () => {});
emitter.on('data', () => {});
console.log(emitter.listenerCount('data')); // Output: 2

emitter.once('data', () => {});
console.log(emitter.listenerCount('data')); // Output: 3
```

### Response
#### Success Response (200)
- **count** (Number) - The number of listeners for the specified event.

#### Response Example
```json
{
  "count": 3
}
```
```

--------------------------------

### Contextual Emits with EventEmitter3

Source: https://github.com/primus/eventemitter3/blob/master/README.md

Use the extended `on`, `once`, and `removeListener` methods to specify a custom context (this value) for emitted events, avoiding the need for `fn.bind`.

```javascript
var EE = new EventEmitter()
  , context = { foo: 'bar' };

function emitted() {
  console.log(this === context); // true
}

EE.once('event-name', emitted, context);
EE.on('another-event', emitted, context);
EE.removeListener('another-event', emitted, context);
```

--------------------------------

### EventEmitter3 - once

Source: https://context7.com/primus/eventemitter3/llms.txt

Adds a one-time listener function that will be automatically removed after being called once. Useful for events that should only trigger a single response.

```APIDOC
## once(event, fn, context)

### Description
Adds a one-time listener function that will be automatically removed after being called once. This is useful for events that should only trigger a single response.

### Method
POST

### Endpoint
/eventemitter3/once

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **event** (string) - Required - The name of the event to listen for.
- **fn** (function) - Required - The listener function to execute once.
- **context** (object) - Optional - The context (`this` value) for the listener function.

### Request Example
```json
{
  "event": "connect",
  "fn": "function() { console.log('Connected!'); }",
  "context": "{ id: 'abc123' }"
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the operation was successful.

#### Response Example
```json
{
  "status": "One-time listener added successfully"
}
```
```

--------------------------------

### Implement type-safe events with TypeScript

Source: https://context7.com/primus/eventemitter3/llms.txt

Utilizes generic interfaces to enforce type safety for event names and listener arguments.

```typescript
import EventEmitter from 'eventemitter3';

// Define typed events
interface MyEvents {
  'user:login': (userId: string, timestamp: Date) => void;
  'user:logout': (userId: string) => void;
  'error': (error: Error) => void;
}

const emitter = new EventEmitter<MyEvents>();

// Type-safe event listeners
emitter.on('user:login', (userId, timestamp) => {
  // userId is typed as string, timestamp as Date
  console.log(`User ${userId} logged in at ${timestamp.toISOString()}`);
});

emitter.on('error', (error) => {
  // error is typed as Error
  console.error('Error occurred:', error.message);
});

// Type-safe emit
emitter.emit('user:login', 'user123', new Date());
emitter.emit('error', new Error('Connection failed'));

// Compilation error examples (uncomment to see TypeScript errors):
// emitter.emit('user:login', 123);  // Error: userId must be string
// emitter.emit('unknown');  // Error: 'unknown' is not a valid event
```

--------------------------------

### EventEmitter3 - on

Source: https://context7.com/primus/eventemitter3/llms.txt

Adds a listener function to an event. The listener will be called every time the event is emitted. An optional context parameter sets the `this` value for the listener function.

```APIDOC
## on(event, fn, context)

### Description
Adds a listener function to an event. The listener will be called every time the event is emitted. An optional context parameter sets the `this` value for the listener function, avoiding the overhead of `fn.bind()`.

### Method
POST

### Endpoint
/eventemitter3/on

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **event** (string) - Required - The name of the event to listen for.
- **fn** (function) - Required - The listener function to execute.
- **context** (object) - Optional - The context (`this` value) for the listener function.

### Request Example
```json
{
  "event": "message",
  "fn": "function(data) { console.log('Received:', data); }",
  "context": "{ name: 'MessageHandler', process: function(data) { console.log(`${this.name} received: ${data}`); } }"
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the operation was successful.

#### Response Example
```json
{
  "status": "Listener added successfully"
}
```
```

--------------------------------

### removeAllListeners

Source: https://context7.com/primus/eventemitter3/llms.txt

Removes all listeners for the specified event, or all listeners entirely if no event is specified.

```APIDOC
## removeAllListeners(event)

### Description
Removes all listeners for the specified event, or all listeners entirely if no event is specified.

### Method
`removeAllListeners`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
const EventEmitter = require('eventemitter3');
const emitter = new EventEmitter();

emitter.on('foo', () => console.log('foo handler'));
emitter.on('bar', () => console.log('bar handler'));

emitter.removeAllListeners('foo'); // Removes all listeners for 'foo'
emitter.removeAllListeners(); // Removes all listeners for all events
```

### Response
#### Success Response (200)
N/A (This is a method call, not an HTTP endpoint)

#### Response Example
N/A
```

--------------------------------

### Remove All Listeners with removeAllListeners

Source: https://context7.com/primus/eventemitter3/llms.txt

Removes all listeners for the specified event, or all listeners entirely if no event is specified. Returns `false` if no listeners were emitted.

```javascript
const EventEmitter = require('eventemitter3');
const emitter = new EventEmitter();

emitter.on('foo', () => console.log('foo handler'));
emitter.on('foo', () => console.log('foo handler 2'));
emitter.on('bar', () => console.log('bar handler'));
emitter.on('baz', () => console.log('baz handler'));

console.log('Events:', emitter.eventNames());  // Output: ['foo', 'bar', 'baz']

// Remove all listeners for 'foo'
emitter.removeAllListeners('foo');
console.log('After removing foo:', emitter.eventNames());  // Output: ['bar', 'baz']

// Remove ALL listeners
emitter.removeAllListeners();
console.log('After removing all:', emitter.eventNames());  // Output: []

// Verify emit returns false
console.log('emit foo:', emitter.emit('foo'));  // Output: false
console.log('emit bar:', emitter.emit('bar'));  // Output: false
```

--------------------------------

### removeListener / off

Source: https://context7.com/primus/eventemitter3/llms.txt

Removes listener(s) for a given event. Can filter by function, context, and whether the listener was added with `once()`.

```APIDOC
## removeListener(event, fn, context, once) / off()

### Description
Removes listener(s) for a given event. If no function is specified, all listeners for that event are removed. Can filter by context and whether the listener was added with `once()`.

### Method
`removeListener` or `off`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
const EventEmitter = require('eventemitter3');
const emitter = new EventEmitter();

function onData(data) {
  console.log('Data:', data);
}

emitter.on('data', onData);
emitter.removeListener('data', onData);

emitter.on('message', () => console.log('A'));
emitter.on('message', () => console.log('B'));
emitter.removeListener('message'); // Removes all listeners for 'message'

const ctx1 = { name: 'ctx1' };
function handler() { console.log('Handler called with context:', this.name); }
emitter.on('event', handler, ctx1);
emitter.removeListener('event', handler, ctx1);
```

### Response
#### Success Response (200)
N/A (This is a method call, not an HTTP endpoint)

#### Response Example
N/A
```

--------------------------------

### Remove Specific Listeners with removeListener/off

Source: https://context7.com/primus/eventemitter3/llms.txt

Removes listener(s) for a given event. If no function is specified, all listeners for that event are removed. Can filter by context and whether the listener was added with `once()`.

```javascript
const EventEmitter = require('eventemitter3');
const emitter = new EventEmitter();

function onData(data) {
  console.log('Data:', data);
}

function onDataBackup(data) {
  console.log('Backup:', data);
}

emitter.on('data', onData);
emitter.on('data', onDataBackup);

console.log('Listeners before:', emitter.listenerCount('data'));  // Output: 2

// Remove specific listener
emitter.removeListener('data', onData);
console.log('Listeners after removing onData:', emitter.listenerCount('data'));  // Output: 1

emitter.emit('data', 'test');  // Output: Backup: test

// Using off() alias
emitter.off('data', onDataBackup);
console.log('Listeners after off():', emitter.listenerCount('data'));  // Output: 0

// Remove all listeners for an event (no function specified)
emitter.on('message', () => console.log('A'));
emitter.on('message', () => console.log('B'));
emitter.removeListener('message');
console.log('Listeners for message:', emitter.listenerCount('message'));  // Output: 0

// Context-specific removal
const ctx1 = { name: 'ctx1' };
const ctx2 = { name: 'ctx2' };

function handler() {
  console.log('Handler called with context:', this.name);
}

emitter.on('event', handler, ctx1);
emitter.on('event', handler, ctx2);

emitter.removeListener('event', handler, ctx1);  // Only removes ctx1 listener
emitter.emit('event');  // Output: Handler called with context: ctx2
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.