### Install @vladfrangu/async_event_emitter

Source: https://context7.com/vladfrangu/async_event_emitter/llms.txt

Install the package using npm or yarn. This is the first step to using the async event emitter in your project.

```bash
npm install @vladfrangu/async_event_emitter
# or
yarn add @vladfrangu/async_event_emitter
```

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

### Register One-Time Listeners with AsyncEventEmitter (TypeScript)

Source: https://context7.com/vladfrangu/async_event_emitter/llms.txt

Illustrates the use of the `once()` method to register listeners that are automatically removed after their first invocation. This is useful for setup or initialization events.

```typescript
import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';

interface Events {
  connected: [host: string, port: number];
  data: [buffer: Buffer];
}

const emitter = new AsyncEventEmitter<Events>();

// This listener fires only once
emitter.once('connected', (host, port) => {
  console.log(`Connected to ${host}:${port}`);
});

// Async one-time listener
emitter.once('connected', async (host, port) => {
  await initializeConnection(host, port);
});

emitter.emit('connected', 'localhost', 3000);
// Output: Connected to localhost:3000

emitter.emit('connected', 'localhost', 3000);
// No output - listener was removed after first call

console.log(emitter.listenerCount('connected')); // Output: 0
```

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

### listeners() / rawListeners() - Get Registered Event Listeners

Source: https://context7.com/vladfrangu/async_event_emitter/llms.txt

Retrieves an array containing the listeners registered for a specific event. `listeners()` returns the original listener functions, while `rawListeners()` returns the listeners exactly as they were added, including any wrappers like `once`.

```typescript
import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';

interface Events {
  data: [value: number];
}

const emitter = new AsyncEventEmitter<Events>();

const handler1 = (value: number) => console.log('Handler 1:', value);
const handler2 = (value: number) => console.log('Handler 2:', value);

emitter.on('data', handler1);
emitter.once('data', handler2); // Once wrapper

// Get unwrapped listeners (original functions)
const listeners = emitter.listeners('data');
console.log('Listeners count:', listeners.length); // Output: 2
console.log('Same as handler1:', listeners[0] === handler1); // Output: true
console.log('Same as handler2:', listeners[1] === handler2); // Output: true

// Get raw listeners (includes once wrappers)
const rawListeners = emitter.rawListeners('data');
console.log('Raw listener 1 is handler1:', rawListeners[0] === handler1); // Output: true
console.log('Raw listener 2 is wrapper:', rawListeners[1] !== handler2); // Output: true
```

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

### Add Listeners to Front using prependListener() / prependOnceListener()

Source: https://context7.com/vladfrangu/async_event_emitter/llms.txt

Adds a listener to the beginning of the listener array for a given event, ensuring it is executed before other registered listeners. `prependOnceListener()` adds a listener that will only be executed once. This is useful for prioritizing certain actions or setting up initial handlers.

```typescript
import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';

interface Events {
  request: [url: string];
}

const emitter = new AsyncEventEmitter<Events>();

emitter.on('request', (url) => console.log('Handler 1:', url));
emitter.on('request', (url) => console.log('Handler 2:', url));

// This handler will be called first
emitter.prependListener('request', (url) => console.log('Prepended:', url));

// One-time prepended listener
emitter.prependOnceListener('request', (url) => console.log('First call only:', url));

emitter.emit('request', '/api/users');
// Output:
// First call only: /api/users
// Prepended: /api/users
// Handler 1: /api/users
// Handler 2: /api/users

emitter.emit('request', '/api/orders');
// Output:
// Prepended: /api/orders
// Handler 1: /api/orders
// Handler 2: /api/orders
```

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

### Create Typed AsyncEventEmitter Instance (TypeScript)

Source: https://context7.com/vladfrangu/async_event_emitter/llms.txt

Demonstrates creating a typed AsyncEventEmitter instance using TypeScript generics. This allows for compile-time checking of event names and their associated arguments.

```typescript
import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';

// Define your events interface for type safety
interface MyEvents {
  userCreated: [userId: string, email: string];
  orderPlaced: [orderId: number, items: string[]];
  serverReady: [];
}

// Create a typed event emitter
const emitter = new AsyncEventEmitter<MyEvents>();

// Events are now fully typed
emitter.on('userCreated', (userId, email) => {
  console.log(`User ${userId} created with email: ${email}`);
});

emitter.emit('userCreated', 'user-123', 'user@example.com');
// Output: User user-123 created with email: user@example.com
```

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

### Emit Events with AsyncEventEmitter (TypeScript)

Source: https://context7.com/vladfrangu/async_event_emitter/llms.txt

Demonstrates how to emit events using the `emit()` method and pass arguments to registered listeners. The method returns a boolean indicating whether any listeners were registered for the event.

```typescript
import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';

interface Events {
  login: [username: string, success: boolean];
  logout: [username: string];
}

const emitter = new AsyncEventEmitter<Events>();

emitter.on('login', (username, success) => {
  if (success) {
    console.log(`${username} logged in successfully`);
  } else {
    console.log(`${username} failed to log in`);
  }
});

// Emit returns true when listeners exist
const hadListeners = emitter.emit('login', 'alice', true);
console.log('Had listeners:', hadListeners); // Output: Had listeners: true

// Emit returns false when no listeners exist
const result = emitter.emit('logout', 'bob');
console.log('Had listeners:', result); // Output: Had listeners: false
```

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

### Register Event Listeners with AsyncEventEmitter (TypeScript)

Source: https://context7.com/vladfrangu/async_event_emitter/llms.txt

Shows how to register both synchronous and asynchronous listeners for events using the `on()` method. Asynchronous listeners returning Promises are automatically tracked by the emitter.

```typescript
import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';

interface Events {
  message: [content: string, timestamp: Date];
  error: [Error];
}

const emitter = new AsyncEventEmitter<Events>();

// Synchronous listener
emitter.on('message', (content, timestamp) => {
  console.log(`[${timestamp.toISOString()}] ${content}`);
});

// Async listener - promises are automatically tracked
emitter.on('message', async (content, timestamp) => {
  await saveToDatabase({ content, timestamp });
  console.log('Message saved to database');
});

// Chain multiple listeners
emitter
  .on('error', (err) => console.error('Error occurred:', err.message))
  .on('error', (err) => sendAlertToSlack(err));

emitter.emit('message', 'Hello World', new Date());
// Output: [2024-01-15T10:30:00.000Z] Hello World
// Output: Message saved to database
```

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

### Configure Listener Limits with setMaxListeners() / getMaxListeners()

Source: https://context7.com/vladfrangu/async_event_emitter/llms.txt

Configure the maximum number of listeners per event before memory leak warnings are shown. This helps manage memory usage in high-throughput scenarios. Setting the limit to 0 disables warnings entirely. The default limit is 10.

```typescript
import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';

interface Events {
  request: [id: number];
}

const emitter = new AsyncEventEmitter<Events>();

// Default max listeners is 10
console.log(emitter.getMaxListeners()); // Output: 10

// Increase limit for high-throughput scenarios
emitter.setMaxListeners(100);
console.log(emitter.getMaxListeners()); // Output: 100

// Set to 0 to disable warnings entirely
emitter.setMaxListeners(0);

// Add many listeners without warnings
for (let i = 0; i < 50; i++) {
  emitter.on('request', (id) => console.log(`Handler ${i}: ${id}`));
}
```

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

### listenerCount() / eventNames() - Query Emitter State

Source: https://context7.com/vladfrangu/async_event_emitter/llms.txt

Provides methods to query the state of the AsyncEventEmitter. `listenerCount()` returns the number of listeners for a specific event, and `eventNames()` returns an array of all event names that have registered listeners.

```typescript
import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';

interface Events {
  open: [];
  close: [];
  data: [chunk: Buffer];
}

const emitter = new AsyncEventEmitter<Events>();

emitter.on('open', () => {});
emitter.on('data', () => {});
emitter.on('data', () => {});
emitter.on('data', () => {});

// Get listener count for specific event
console.log(emitter.listenerCount('data')); // Output: 3
console.log(emitter.listenerCount('open')); // Output: 1
console.log(emitter.listenerCount('close')); // Output: 0

// Static method alternative
console.log(AsyncEventEmitter.listenerCount(emitter, 'data')); // Output: 3

// Get all event names with registered listeners
console.log(emitter.eventNames()); // Output: ['open', 'data']
```

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

### Predefined Events: newListener and removeListener

Source: https://context7.com/vladfrangu/async_event_emitter/llms.txt

Built-in events that fire automatically when listeners are added ('newListener') or removed ('removeListener') from the emitter. These events allow for dynamic tracking and management of event listeners within the application.

```typescript
import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';

interface Events {
  data: [value: string];
}

const emitter = new AsyncEventEmitter<Events>();

// Track when listeners are added
emitter.on('newListener', (eventName, listener) => {
  console.log(`New listener added for "${String(eventName)}"`);
});

// Track when listeners are removed
emitter.on('removeListener', (eventName, listener) => {
  console.log(`Listener removed from "${String(eventName)}"`);
});

const dataHandler = (value: string) => console.log(value);

emitter.on('data', dataHandler);
// Output: New listener added for "data"

emitter.off('data', dataHandler);
// Output: Listener removed from "data"
```

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

### AsyncEventEmitter.on() - Consume Events as Async Iterator

Source: https://context7.com/vladfrangu/async_event_emitter/llms.txt

Creates an async iterator that yields event arguments whenever the specified event is emitted. This is useful for processing events in a loop as a stream. The loop can be broken manually.

```typescript
import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';

interface Events {
  message: [content: string, from: string];
  disconnect: [];
}

const chat = new AsyncEventEmitter<Events>();

async function processMessages() {
  const iterator = AsyncEventEmitter.on(chat, 'message');

  for await (const [content, from] of iterator) {
    console.log(`${from}: ${content}`);

    // Break condition to stop listening
    if (content === 'quit') {
      break;
    }
  }

  console.log('Stopped listening for messages');
}

// Start processing in the background
processMessages();

// Simulate incoming messages
setTimeout(() => chat.emit('message', 'Hello!', 'Alice'), 100);
setTimeout(() => chat.emit('message', 'How are you?', 'Bob'), 200);
setTimeout(() => chat.emit('message', 'quit', 'Alice'), 300);

// Output:
// Alice: Hello!
// Bob: How are you?
// Alice: quit
// Stopped listening for messages
```

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

### AsyncEventEmitter.once() - Wait for Event Once with Promise

Source: https://context7.com/vladfrangu/async_event_emitter/llms.txt

Waits for a specific event to be emitted once by the provided AsyncEventEmitter instance. It returns a Promise that resolves with an array of the emitted event's arguments. Supports AbortSignal for cancellation.

```typescript
import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';

interface Events {
  ready: [port: number];
  connected: [host: string, port: number];
}

const server = new AsyncEventEmitter<Events>();

async function waitForServer() {
  // Wait for the ready event
  const [port] = await AsyncEventEmitter.once(server, 'ready');
  console.log(`Server ready on port ${port}`);
  return port;
}

// With AbortSignal for timeout
async function connectWithTimeout() {
  const controller = new AbortController();
  const timeout = setTimeout(() => controller.abort(), 5000);

  try {
    const [host, port] = await AsyncEventEmitter.once(server, 'connected', {
      signal: controller.signal
    });
    console.log(`Connected to ${host}:${port}`);
    clearTimeout(timeout);
    return { host, port };
  } catch (error) {
    if (error.name === 'AbortError') {
      console.log('Connection timed out');
    }
    throw error;
  }
}

// Simulate server starting
setTimeout(() => server.emit('ready', 3000), 100);

waitForServer(); // Output: Server ready on port 3000 (after 100ms)
```

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

### Automatic Promise Rejection Capture for Error Handling

Source: https://context7.com/vladfrangu/async_event_emitter/llms.txt

Async listeners that throw errors or return rejected promises automatically emit an 'error' event. It is crucial to add an 'error' event handler to prevent unhandled rejections from crashing the application. This ensures that errors in asynchronous operations are properly caught and managed.

```typescript
import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';

interface Events {
  process: [data: object];
  error: [Error];
}

const emitter = new AsyncEventEmitter<Events>();

// Always add an error handler to prevent unhandled rejections
emitter.on('error', (error) => {
  console.error('Caught error:', error.message);
  // Log to monitoring service, retry, etc.
});

// Async handler that might fail
emitter.on('process', async (data) => {
  if (!data.id) {
    throw new Error('Missing required id field');
  }
  await processData(data);
});

// Handler returning rejected promise
emitter.on('process', (data) => {
  return fetch('/api/process', {
    method: 'POST',
    body: JSON.stringify(data)
  }).then(res => {
    if (!res.ok) throw new Error('API request failed');
  });
});

// Emit event - errors are caught and re-emitted
emitter.emit('process', { name: 'test' }); // Missing id
// Output: Caught error: Missing required id field

// Without error handler, unhandled error events throw
const unsafeEmitter = new AsyncEventEmitter();
unsafeEmitter.emit('error', new Error('Unhandled!')); // Throws!
```

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

### Wait for Async Handlers using waitForAllListenersToComplete()

Source: https://context7.com/vladfrangu/async_event_emitter/llms.txt

Waits for all currently executing asynchronous event handlers to complete their execution. This method returns a boolean indicating if there were any pending promises. It is essential for scenarios requiring graceful shutdown, ensuring all operations are finished before proceeding.

```typescript
import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';

interface Events {
  shutdown: [];
  save: [data: object];
}

const emitter = new AsyncEventEmitter<Events>();

// Async listeners that take time to complete
emitter.on('save', async (data) => {
  await new Promise(resolve => setTimeout(resolve, 100));
  console.log('Data saved to primary DB');
});

emitter.on('save', async (data) => {
  await new Promise(resolve => setTimeout(resolve, 200));
  console.log('Data saved to backup DB');
});

async function main() {
  console.log('Emitting save event...');
  emitter.emit('save', { user: 'alice', action: 'logout' });

  console.log('Waiting for all handlers...');
  const hadPendingPromises = await emitter.waitForAllListenersToComplete();

  console.log('All handlers completed:', hadPendingPromises);
  console.log('Safe to exit now');
}

main();
// Output:
// Emitting save event...
// Waiting for all handlers...
// Data saved to primary DB (after 100ms)
// Data saved to backup DB (after 200ms)
// All handlers completed: true
// Safe to exit now
```

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

### Remove All Event Listeners using removeAllListeners()

Source: https://context7.com/vladfrangu/async_event_emitter/llms.txt

Removes all listeners for a specified event or all listeners for all events. This method is crucial for resetting the emitter's state or performing a complete cleanup. Calling `removeAllListeners()` without arguments clears all event handlers.

```typescript
import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';

interface Events {
  eventA: [];
  eventB: [data: string];
}

const emitter = new AsyncEventEmitter<Events>();

emitter.on('eventA', () => console.log('A1'));
emitter.on('eventA', () => console.log('A2'));
emitter.on('eventB', (data) => console.log('B:', data));

console.log(emitter.listenerCount('eventA')); // Output: 2
console.log(emitter.listenerCount('eventB')); // Output: 1

// Remove all listeners for specific event
emitter.removeAllListeners('eventA');
console.log(emitter.listenerCount('eventA')); // Output: 0
console.log(emitter.listenerCount('eventB')); // Output: 1

// Remove all listeners for all events
emitter.removeAllListeners();
console.log(emitter.listenerCount('eventB')); // Output: 0
```

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

### Remove Specific Event Listener using off() or removeListener()

Source: https://context7.com/vladfrangu/async_event_emitter/llms.txt

Removes a specific listener function associated with an event. The `off()` method serves as an alias for `removeListener()`. This is useful for cleaning up event handlers when they are no longer needed, preventing memory leaks and unintended behavior.

```typescript
import { AsyncEventEmitter } from '@vladfrangu/async_event_emitter';

interface Events {
  tick: [count: number];
}

const emitter = new AsyncEventEmitter<Events>();

const tickHandler = (count: number) => {
  console.log(`Tick: ${count}`);
};

emitter.on('tick', tickHandler);

emitter.emit('tick', 1); // Output: Tick: 1
emitter.emit('tick', 2); // Output: Tick: 2

// Remove the listener
emitter.off('tick', tickHandler);
// or: emitter.removeListener('tick', tickHandler);

emitter.emit('tick', 3); // No output - listener removed
```

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