Promisify an event by waiting for it to be emitted
npm install p-event> Promisify an event by waiting for it to be emitted
Useful when you need only one event emission and want to use it with promises or await it in an async function.
It works with any event API in Node.js and the browser (using a bundler).
If you want multiple individual events as they are emitted, you can use the pEventIterator() method. Observables can be useful too.
``sh`
npm install p-event
In Node.js:
`js
import {pEvent} from 'p-event';
import emitter from './some-event-emitter';
try {
const result = await pEvent(emitter, 'finish');
// emitter emitted a finish eventemitter
console.log(result);
} catch (error) {
// emitted an error event`
console.error(error);
}
In the browser:
`js
import {pEvent} from 'p-event';
await pEvent(document, 'DOMContentLoaded');
console.log('😎');
`
Async iteration:
`js
import {pEventIterator} from 'p-event';
import emitter from './some-event-emitter';
const asyncIterator = pEventIterator(emitter, 'data', {
resolutionEvents: ['finish']
});
for await (const event of asyncIterator) {
console.log(event);
}
`
Returns a Promise that is fulfilled when emitter emits an event matching event, or rejects if emitter emits any of the events defined in the rejectionEvents option.
Note: event is a string for a single event type, for example, 'data'. To listen on multiple['started', 'stopped']
events, pass an array of strings, such as .
The returned promise has a .cancel() method, which when called, removes the event listeners and causes the promise to never be settled. However, for new code, it's recommended to use the signal option instead.
#### emitter
Type: object
Event emitter object.
Should have either a .on()/.addListener()/.addEventListener() and .off()/.removeListener()/.removeEventListener() method, like the Node.js EventEmitter and DOM events.
#### event
Type: string | string[]
Name of the event or events to listen to.
If the same event is defined both here and in rejectionEvents, this one takes priority.
#### options
Type: object
##### rejectionEvents
Type: string[]\['error']
Default:
Events that will reject the promise.
##### multiArgs
Type: boolean\false
Default:
By default, the promisified function will only return the first argument from the event callback, which works fine for most APIs. This option can be useful for APIs that return multiple arguments in the callback. Turning this on will make it return an array of all arguments from the callback, instead of just the first argument.
Example:
`js
import {pEvent} from 'p-event';
import emitter from './some-event-emitter';
const [foo, bar] = await pEvent(emitter, 'finish', {multiArgs: true});
`
##### rejectionMultiArgs
Type: boolean\false
Default:
By default, rejection events will only return the first argument from the event callback. Turning this on will make it return an array of all arguments from the rejection event callback.
Example:
`js
import {pEvent} from 'p-event';
import emitter from './some-event-emitter';
try {
await pEvent(emitter, 'finish', {rejectionMultiArgs: true});
} catch (error) {
// If rejection event emits multiple arguments, error will be an array
console.log(error); // ['error', 'details', 'code']
}
`
##### timeout
Type: number\Infinity
Default:
Time in milliseconds before timing out.
##### filter
Type: Function
A filter function for accepting an event. Can be synchronous or asynchronous.
`js
import {pEvent} from 'p-event';
import emitter from './some-event-emitter';
// Synchronous filter
const result = await pEvent(emitter, '🦄', value => value > 3);
// Do something with first 🦄 event with a value greater than 3
// Asynchronous filter (e.g., API validation)
const result2 = await pEvent(emitter, 'data', async value => {
const isValid = await validateWithAPI(value);
return isValid;
});
// Do something with first 'data' event that passes async validation
`
> [!NOTE]
> If the filter function throws an error or returns a rejected promise, the promise returned by pEvent will be rejected with that error. If you want to handle filter errors gracefully, wrap your filter logic in a try-catch block and return false for invalid events.
##### signal
Type: AbortSignal
An AbortSignal to abort waiting for the event.
Wait for multiple event emissions. Returns an array.
This method has the same arguments and options as pEvent() with the addition of the following options:
#### options
Type: object
##### count
Required\
Type: number
The number of times the event needs to be emitted before the promise resolves.
##### resolveImmediately
Type: boolean\false
Default:
Whether to resolve the promise immediately. Emitting one of the rejectionEvents won't throw an error.
Note: The returned array will be mutated when an event is emitted.
Example:
`js
import {pEventMultiple} from 'p-event';
const emitter = new EventEmitter();
const promise = pEventMultiple(emitter, 'hello', {
resolveImmediately: true,
count: Infinity
});
const result = await promise;
console.log(result);
//=> []
emitter.emit('hello', 'Jack');
console.log(result);
//=> ['Jack']
emitter.emit('hello', 'Mark');
console.log(result);
//=> ['Jack', 'Mark']
// Stops listening
emitter.emit('error', new Error('😿'));
emitter.emit('hello', 'John');
console.log(result);
//=> ['Jack', 'Mark']
`
Returns an async iterator that lets you asynchronously iterate over events of event emitted from emitter. The iterator ends when emitter emits an event matching any of the events defined in resolutionEvents, or rejects if emitter emits any of the events defined in the rejectionEvents option.
This method has the same arguments and options as pEvent() with the addition of the following options:
#### options
Type: object
##### limit
Type: number (non-negative integer)\Infinity
Default:
The maximum number of events for the iterator before it ends. When the limit is reached, the iterator will be marked as done. This option is useful to paginate events, for example, fetching 10 events per page.
##### resolutionEvents
Type: string[]\[]
Default:
Events that will end the iterator.
Exposed for instance checking and sub-classing.
Example:
`js
import {pEvent} from 'p-event';
try {
await pEvent(emitter, 'finish');
} catch (error) {
if (error instanceof pEvent.TimeoutError) {
// Do something specific for timeout errors
}
}
`
`js
import fs from 'node:fs';
function getOpenReadStream(file, callback) {
const stream = fs.createReadStream(file);
stream.on('open', () => {
callback(null, stream);
});
stream.on('error', error => {
callback(error);
});
}
getOpenReadStream('unicorn.txt', (error, stream) => {
if (error) {
console.error(error);
return;
}
console.log('File descriptor:', stream.fd);
stream.pipe(process.stdout);
});
`
`js
import fs from 'node:fs';
import {pEvent} from 'p-event';
async function getOpenReadStream(file) {
const stream = fs.createReadStream(file);
await pEvent(stream, 'open');
return stream;
}
(async () => {
const stream = await getOpenReadStream('unicorn.txt');
console.log('File descriptor:', stream.fd);
stream.pipe(process.stdout);
})()
.catch(console.error);
`
If you're using .cancel() in existing code, here's how to migrate to the preferred AbortSignal approach:
`js
// Before
const promise = pEvent(emitter, 'finish');
// ... later
promise.cancel();
// After
const controller = new AbortController();
const promise = pEvent(emitter, 'finish', {
signal: controller.signal
});
// ... later
controller.abort();
`
Some functions might use a single event for success and for certain errors. Promises make it easy to have combined error handler for both error events and successes containing values which represent errors.
`js
import {pEvent} from 'p-event';
import emitter from './some-event-emitter';
try {
const result = await pEvent(emitter, 'finish');
if (result === 'unwanted result') {
throw new Error('Emitter finished with an error');
}
// emitter emitted a finish event with an acceptable valueemitter
console.log(result);
} catch (error) {
// emitted an error event orfinish
// emitted a with 'unwanted result'``
console.error(error);
}
- pify - Promisify a callback-style function
- p-map - Map over promises concurrently
- More…