Socket
Socket
Sign inDemoInstall

p-event

Package Overview
Dependencies
1
Maintainers
1
Versions
17
Alerts
File Explorer

Advanced tools

npm Scripts

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 4.2.0 to 5.0.0

410

index.d.ts

@@ -1,265 +0,237 @@

/// <reference lib="esnext"/>
export type AddRemoveListener<EventName extends string | symbol, Arguments extends unknown[]> = (
event: EventName,
listener: (...arguments: Arguments) => void
) => void;
declare class TimeoutErrorClass extends Error {
readonly name: 'TimeoutError';
constructor(message?: string);
export interface Emitter<EventName extends string | symbol, EmittedType extends unknown[]> {
on?: AddRemoveListener<EventName, EmittedType>;
addListener?: AddRemoveListener<EventName, EmittedType>;
addEventListener?: AddRemoveListener<EventName, EmittedType>;
off?: AddRemoveListener<EventName, EmittedType>;
removeListener?: AddRemoveListener<EventName, EmittedType>;
removeEventListener?: AddRemoveListener<EventName, EmittedType>;
}
declare namespace pEvent {
type TimeoutError = TimeoutErrorClass;
export type FilterFunction<ElementType extends unknown[]> = (
...arguments: ElementType
) => boolean;
type AddRemoveListener<EventName extends string | symbol, Arguments extends unknown[]> = (
event: EventName,
listener: (...arguments: Arguments) => void
) => void;
export interface CancelablePromise<ResolveType> extends Promise<ResolveType> {
cancel(): void;
}
interface Emitter<EventName extends string | symbol, EmittedType extends unknown[]> {
on?: AddRemoveListener<EventName, EmittedType>;
addListener?: AddRemoveListener<EventName, EmittedType>;
addEventListener?: AddRemoveListener<EventName, EmittedType>;
off?: AddRemoveListener<EventName, EmittedType>;
removeListener?: AddRemoveListener<EventName, EmittedType>;
removeEventListener?: AddRemoveListener<EventName, EmittedType>;
}
export interface Options<EmittedType extends unknown[]> {
/**
Events that will reject the promise.
type FilterFunction<ElementType extends unknown[]> = (
...arguments: ElementType
) => boolean;
@default ['error']
*/
readonly rejectionEvents?: ReadonlyArray<string | symbol>;
interface CancelablePromise<ResolveType> extends Promise<ResolveType> {
cancel(): void;
}
/**
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. This also applies to rejections.
interface Options<EmittedType extends unknown[]> {
/**
Events that will reject the promise.
@default false
@default ['error']
*/
readonly rejectionEvents?: ReadonlyArray<string | symbol>;
@example
```
import {pEvent} from 'p-event';
import emitter from './some-event-emitter';
/**
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. This also applies to rejections.
const [foo, bar] = await pEvent(emitter, 'finish', {multiArgs: true});
```
*/
readonly multiArgs?: boolean;
@default false
/**
The time in milliseconds before timing out.
@example
```
import pEvent = require('p-event');
import emitter from './some-event-emitter';
@default Infinity
*/
readonly timeout?: number;
(async () => {
const [foo, bar] = await pEvent(emitter, 'finish', {multiArgs: true});
})();
```
*/
readonly multiArgs?: boolean;
/**
A filter function for accepting an event.
/**
Time in milliseconds before timing out.
@example
```
import {pEvent} from 'p-event';
import emitter from './some-event-emitter';
@default Infinity
*/
readonly timeout?: number;
const result = await pEvent(emitter, '🦄', value => value > 3);
// Do something with first 🦄 event with a value greater than 3
```
*/
readonly filter?: FilterFunction<EmittedType>;
}
/**
Filter function for accepting an event.
export interface MultiArgumentsOptions<EmittedType extends unknown[]>
extends Options<EmittedType> {
readonly multiArgs: true;
}
@example
```
import pEvent = require('p-event');
import emitter from './some-event-emitter';
export interface MultipleOptions<EmittedType extends unknown[]>
extends Options<EmittedType> {
/**
The number of times the event needs to be emitted before the promise resolves.
*/
readonly count: number;
(async () => {
const result = await pEvent(emitter, '🦄', value => value > 3);
// Do something with first 🦄 event with a value greater than 3
})();
```
*/
readonly filter?: FilterFunction<EmittedType>;
}
/**
Whether to resolve the promise immediately. Emitting one of the `rejectionEvents` won't throw an error.
interface MultiArgumentsOptions<EmittedType extends unknown[]>
extends Options<EmittedType> {
readonly multiArgs: true;
}
__Note__: The returned array will be mutated when an event is emitted.
interface MultipleOptions<EmittedType extends unknown[]>
extends Options<EmittedType> {
/**
The number of times the event needs to be emitted before the promise resolves.
*/
readonly count: number;
@example
```
import {pEventMultiple} from 'p-event';
/**
Whether to resolve the promise immediately. Emitting one of the `rejectionEvents` won't throw an error.
const emitter = new EventEmitter();
__Note__: The returned array will be mutated when an event is emitted.
const promise = pEventMultiple(emitter, 'hello', {
resolveImmediately: true,
count: Infinity
});
@example
```
import pEvent = require('p-event');
const result = await promise;
console.log(result);
//=> []
const emitter = new EventEmitter();
emitter.emit('hello', 'Jack');
console.log(result);
//=> ['Jack']
const promise = pEvent.multiple(emitter, 'hello', {
resolveImmediately: true,
count: Infinity
});
emitter.emit('hello', 'Mark');
console.log(result);
//=> ['Jack', 'Mark']
const result = await promise;
console.log(result);
//=> []
// Stops listening
emitter.emit('error', new Error('😿'));
emitter.emit('hello', 'Jack');
console.log(result);
//=> ['Jack']
emitter.emit('hello', 'John');
console.log(result);
//=> ['Jack', 'Mark']
```
*/
readonly resolveImmediately?: boolean;
}
emitter.emit('hello', 'Mark');
console.log(result);
//=> ['Jack', 'Mark']
export interface MultipleMultiArgumentsOptions<EmittedType extends unknown[]>
extends MultipleOptions<EmittedType> {
readonly multiArgs: true;
}
// Stops listening
emitter.emit('error', new Error('😿'));
export interface IteratorOptions<EmittedType extends unknown[]>
extends Options<EmittedType> {
/**
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.
emitter.emit('hello', 'John');
console.log(result);
//=> ['Jack', 'Mark']
```
*/
readonly resolveImmediately?: boolean;
}
@default Infinity
*/
readonly limit?: number;
interface MultipleMultiArgumentsOptions<EmittedType extends unknown[]>
extends MultipleOptions<EmittedType> {
readonly multiArgs: true;
}
/**
Events that will end the iterator.
interface IteratorOptions<EmittedType extends unknown[]>
extends Options<EmittedType> {
/**
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.
@default []
*/
readonly resolutionEvents?: ReadonlyArray<string | symbol>;
}
@default Infinity
*/
limit?: number;
/**
Events that will end the iterator.
@default []
*/
resolutionEvents?: ReadonlyArray<string | symbol>;
}
interface IteratorMultiArgumentsOptions<EmittedType extends unknown[]>
extends IteratorOptions<EmittedType> {
multiArgs: true;
}
export interface IteratorMultiArgumentsOptions<EmittedType extends unknown[]>
extends IteratorOptions<EmittedType> {
multiArgs: true;
}
declare const pEvent: {
/**
Promisify an event by waiting for it to be emitted.
/**
Promisify an event by waiting for it to be emitted.
@param emitter - Event emitter object. Should have either a `.on()`/`.addListener()`/`.addEventListener()` and `.off()`/`.removeListener()`/`.removeEventListener()` method, like the [Node.js `EventEmitter`](https://nodejs.org/api/events.html) and [DOM events](https://developer.mozilla.org/en-US/docs/Web/Events).
@param event - Name of the event or events to listen to. If the same event is defined both here and in `rejectionEvents`, this one takes priority.*Note**: `event` is a string for a single event type, for example, `'data'`. To listen on multiple events, pass an array of strings, such as `['started', 'stopped']`.
@returns Fulfills when emitter emits an event matching `event`, or rejects if emitter emits any of the events defined in the `rejectionEvents` option. The returned promise has a `.cancel()` method, which when called, removes the event listeners and causes the promise to never be settled.
@param emitter - Event emitter object. Should have either a `.on()`/`.addListener()`/`.addEventListener()` and `.off()`/`.removeListener()`/`.removeEventListener()` method, like the [Node.js `EventEmitter`](https://nodejs.org/api/events.html) and [DOM events](https://developer.mozilla.org/en-US/docs/Web/Events).
@param event - Name of the event or events to listen to. If the same event is defined both here and in `rejectionEvents`, this one takes priority.*Note**: `event` is a string for a single event type, for example, `'data'`. To listen on multiple events, pass an array of strings, such as `['started', 'stopped']`.
@returns Fulfills when emitter emits an event matching `event`, or rejects if emitter emits any of the events defined in the `rejectionEvents` option. The returned promise has a `.cancel()` method, which when called, removes the event listeners and causes the promise to never be settled.
@example
```
// In Node.js:
import pEvent = require('p-event');
import emitter from './some-event-emitter';
@example
```
import {pEvent} = require('p-event');
import emitter from './some-event-emitter';
(async () => {
try {
const result = await pEvent(emitter, 'finish');
// In Node.js:
try {
const result = await pEvent(emitter, 'finish');
// `emitter` emitted a `finish` event
console.log(result);
} catch (error) {
// `emitter` emitted an `error` event
console.error(error);
}
})();
// `emitter` emitted a `finish` event
console.log(result);
} catch (error) {
// `emitter` emitted an `error` event
console.error(error);
}
// In the browser:
(async () => {
await pEvent(document, 'DOMContentLoaded');
console.log('😎');
})();
```
*/
<EventName extends string | symbol, EmittedType extends unknown[]>(
emitter: pEvent.Emitter<EventName, EmittedType>,
event: string | symbol | ReadonlyArray<string | symbol>,
options: pEvent.MultiArgumentsOptions<EmittedType>
): pEvent.CancelablePromise<EmittedType>;
<EventName extends string | symbol, EmittedType>(
emitter: pEvent.Emitter<EventName, [EmittedType]>,
event: string | symbol | ReadonlyArray<string | symbol>,
filter: pEvent.FilterFunction<[EmittedType]>
): pEvent.CancelablePromise<EmittedType>;
<EventName extends string | symbol, EmittedType>(
emitter: pEvent.Emitter<EventName, [EmittedType]>,
event: string | symbol | ReadonlyArray<string | symbol>,
options?: pEvent.Options<[EmittedType]>
): pEvent.CancelablePromise<EmittedType>;
// In the browser:
await pEvent(document, 'DOMContentLoaded');
console.log('😎');
```
*/
export function pEvent<EventName extends string | symbol, EmittedType extends unknown[]>(
emitter: Emitter<EventName, EmittedType>,
event: string | symbol | ReadonlyArray<string | symbol>,
options: MultiArgumentsOptions<EmittedType>
): CancelablePromise<EmittedType>;
export function pEvent<EventName extends string | symbol, EmittedType>(
emitter: Emitter<EventName, [EmittedType]>,
event: string | symbol | ReadonlyArray<string | symbol>,
filter: FilterFunction<[EmittedType]>
): CancelablePromise<EmittedType>;
export function pEvent<EventName extends string | symbol, EmittedType>(
emitter: Emitter<EventName, [EmittedType]>,
event: string | symbol | ReadonlyArray<string | symbol>,
options?: Options<[EmittedType]>
): CancelablePromise<EmittedType>;
/**
Wait for multiple event emissions. Returns an array.
*/
multiple<EventName extends string | symbol, EmittedType extends unknown[]>(
emitter: pEvent.Emitter<EventName, EmittedType>,
event: string | symbol | ReadonlyArray<string | symbol>,
options: pEvent.MultipleMultiArgumentsOptions<EmittedType>
): pEvent.CancelablePromise<EmittedType[]>;
multiple<EventName extends string | symbol, EmittedType>(
emitter: pEvent.Emitter<EventName, [EmittedType]>,
event: string | symbol | ReadonlyArray<string | symbol>,
options: pEvent.MultipleOptions<[EmittedType]>
): pEvent.CancelablePromise<EmittedType[]>;
/**
Wait for multiple event emissions.
*/
export function pEventMultiple<EventName extends string | symbol, EmittedType extends unknown[]>(
emitter: Emitter<EventName, EmittedType>,
event: string | symbol | ReadonlyArray<string | symbol>,
options: MultipleMultiArgumentsOptions<EmittedType>
): CancelablePromise<EmittedType[]>;
export function pEventMultiple<EventName extends string | symbol, EmittedType>(
emitter: Emitter<EventName, [EmittedType]>,
event: string | symbol | ReadonlyArray<string | symbol>,
options: MultipleOptions<[EmittedType]>
): CancelablePromise<EmittedType[]>;
/**
@returns An [async iterator](https://2ality.com/2016/10/asynchronous-iteration.html) 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.
/**
@returns An [async iterator](https://2ality.com/2016/10/asynchronous-iteration.html) 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.
@example
```
import pEvent = require('p-event');
import emitter from './some-event-emitter';
@example
```
import {pEventIterator} from 'p-event';
import emitter from './some-event-emitter';
(async () => {
const asyncIterator = pEvent.iterator(emitter, 'data', {
resolutionEvents: ['finish']
});
const asyncIterator = pEventIterator(emitter, 'data', {
resolutionEvents: ['finish']
});
for await (const event of asyncIterator) {
console.log(event);
}
})();
```
*/
iterator<EventName extends string | symbol, EmittedType extends unknown[]>(
emitter: pEvent.Emitter<EventName, EmittedType>,
event: string | symbol | ReadonlyArray<string | symbol>,
options: pEvent.IteratorMultiArgumentsOptions<EmittedType>
): AsyncIterableIterator<EmittedType>;
iterator<EventName extends string | symbol, EmittedType>(
emitter: pEvent.Emitter<EventName, [EmittedType]>,
event: string | symbol | ReadonlyArray<string | symbol>,
filter: pEvent.FilterFunction<[EmittedType]>
): AsyncIterableIterator<EmittedType>;
iterator<EventName extends string | symbol, EmittedType>(
emitter: pEvent.Emitter<EventName, [EmittedType]>,
event: string | symbol | ReadonlyArray<string | symbol>,
options?: pEvent.IteratorOptions<[EmittedType]>
): AsyncIterableIterator<EmittedType>;
for await (const event of asyncIterator) {
console.log(event);
}
```
*/
export function pEventIterator<EventName extends string | symbol, EmittedType extends unknown[]>(
emitter: Emitter<EventName, EmittedType>,
event: string | symbol | ReadonlyArray<string | symbol>,
options: IteratorMultiArgumentsOptions<EmittedType>
): AsyncIterableIterator<EmittedType>;
export function pEventIterator<EventName extends string | symbol, EmittedType>(
emitter: Emitter<EventName, [EmittedType]>,
event: string | symbol | ReadonlyArray<string | symbol>,
filter: FilterFunction<[EmittedType]>
): AsyncIterableIterator<EmittedType>;
export function pEventIterator<EventName extends string | symbol, EmittedType>(
emitter: Emitter<EventName, [EmittedType]>,
event: string | symbol | ReadonlyArray<string | symbol>,
options?: IteratorOptions<[EmittedType]>
): AsyncIterableIterator<EmittedType>;
// TODO: Remove this for the next major release
default: typeof pEvent;
TimeoutError: typeof TimeoutErrorClass;
};
export = pEvent;
export {TimeoutError} from 'p-timeout';

92

index.js

@@ -1,6 +0,3 @@

'use strict';
const pTimeout = require('p-timeout');
import pTimeout from 'p-timeout';
const symbolAsyncIterator = Symbol.asyncIterator || '@@asyncIterator';
const normalizeEmitter = emitter => {

@@ -16,11 +13,9 @@ const addListener = emitter.on || emitter.addListener || emitter.addEventListener;

addListener: addListener.bind(emitter),
removeListener: removeListener.bind(emitter)
removeListener: removeListener.bind(emitter),
};
};
const toArray = value => Array.isArray(value) ? value : [value];
const multiple = (emitter, event, options) => {
export function pEventMultiple(emitter, event, options) {
let cancel;
const ret = new Promise((resolve, reject) => {
const returnValue = new Promise((resolve, reject) => {
options = {

@@ -30,6 +25,6 @@ rejectionEvents: ['error'],

resolveImmediately: false,
...options
...options,
};
if (!(options.count >= 0 && (options.count === Infinity || Number.isInteger(options.count)))) {
if (!(options.count >= 0 && (options.count === Number.POSITIVE_INFINITY || Number.isInteger(options.count)))) {
throw new TypeError('The `count` option should be at least 0 or more');

@@ -39,3 +34,3 @@ }

// Allow multiple events
const events = toArray(event);
const events = [event].flat();

@@ -45,5 +40,6 @@ const items = [];

const onItem = (...args) => {
const value = options.multiArgs ? args : args[0];
const onItem = (...arguments_) => {
const value = options.multiArgs ? arguments_ : arguments_[0];
// eslint-disable-next-line unicorn/no-array-callback-reference
if (options.filter && !options.filter(value)) {

@@ -89,6 +85,6 @@ return;

ret.cancel = cancel;
returnValue.cancel = cancel;
if (typeof options.timeout === 'number') {
const timeout = pTimeout(ret, options.timeout);
const timeout = pTimeout(returnValue, options.timeout);
timeout.cancel = cancel;

@@ -98,6 +94,6 @@ return timeout;

return ret;
};
return returnValue;
}
const pEvent = (emitter, event, options) => {
export function pEvent(emitter, event, options) {
if (typeof options === 'function') {

@@ -110,6 +106,6 @@ options = {filter: options};

count: 1,
resolveImmediately: false
resolveImmediately: false,
};
const arrayPromise = multiple(emitter, event, options);
const arrayPromise = pEventMultiple(emitter, event, options);
const promise = arrayPromise.then(array => array[0]); // eslint-disable-line promise/prefer-await-to-then

@@ -119,11 +115,5 @@ promise.cancel = arrayPromise.cancel;

return promise;
};
}
module.exports = pEvent;
// TODO: Remove this for the next major release
module.exports.default = pEvent;
module.exports.multiple = multiple;
module.exports.iterator = (emitter, event, options) => {
export function pEventIterator(emitter, event, options) {
if (typeof options === 'function') {

@@ -134,3 +124,3 @@ options = {filter: options};

// Allow multiple events
const events = toArray(event);
const events = [event].flat();

@@ -140,9 +130,9 @@ options = {

resolutionEvents: [],
limit: Infinity,
limit: Number.POSITIVE_INFINITY,
multiArgs: false,
...options
...options,
};
const {limit} = options;
const isValidLimit = limit >= 0 && (limit === Infinity || Number.isInteger(limit));
const isValidLimit = limit >= 0 && (limit === Number.POSITIVE_INFINITY || Number.isInteger(limit));
if (!isValidLimit) {

@@ -161,5 +151,5 @@ throw new TypeError('The `limit` option should be a non-negative integer or Infinity');

done: true,
value: undefined
value: undefined,
};
}
},
};

@@ -178,7 +168,7 @@ }

const valueHandler = (...args) => {
const valueHandler = (...arguments_) => {
eventCount++;
isLimitReached = eventCount === limit;
const value = options.multiArgs ? args : args[0];
const value = options.multiArgs ? arguments_ : arguments_[0];

@@ -206,2 +196,3 @@ if (nextQueue.length > 0) {

isDone = true;
for (const event of events) {

@@ -225,4 +216,4 @@ removeListener(event, valueHandler);

const rejectHandler = (...args) => {
error = options.multiArgs ? args : args[0];
const rejectHandler = (...arguments_) => {
error = options.multiArgs ? arguments_ : arguments_[0];

@@ -239,5 +230,6 @@ if (nextQueue.length > 0) {

const resolveHandler = (...args) => {
const value = options.multiArgs ? args : args[0];
const resolveHandler = (...arguments_) => {
const value = options.multiArgs ? arguments_ : arguments_[0];
// eslint-disable-next-line unicorn/no-array-callback-reference
if (options.filter && !options.filter(value)) {

@@ -270,3 +262,3 @@ return;

return {
[symbolAsyncIterator]() {
[Symbol.asyncIterator]() {
return this;

@@ -279,3 +271,3 @@ },

done: isDone && valueQueue.length === 0 && !isLimitReached,
value
value,
};

@@ -292,7 +284,9 @@ }

done: true,
value: undefined
value: undefined,
};
}
return new Promise((resolve, reject) => nextQueue.push({resolve, reject}));
return new Promise((resolve, reject) => {
nextQueue.push({resolve, reject});
});
},

@@ -303,8 +297,8 @@ async return(value) {

done: isDone,
value
value,
};
}
},
};
};
}
module.exports.TimeoutError = pTimeout.TimeoutError;
export {TimeoutError} from 'p-timeout';

18

package.json
{
"name": "p-event",
"version": "4.2.0",
"version": "5.0.0",
"description": "Promisify an event by waiting for it to be emitted",

@@ -13,4 +13,6 @@ "license": "MIT",

},
"type": "module",
"exports": "./index.js",
"engines": {
"node": ">=8"
"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
},

@@ -48,11 +50,11 @@ "scripts": {

"dependencies": {
"p-timeout": "^3.1.0"
"p-timeout": "^5.0.2"
},
"devDependencies": {
"@types/node": "^12.0.2",
"ava": "^1.4.1",
"delay": "^4.1.0",
"tsd": "^0.11.0",
"xo": "^0.24.0"
"@types/node": "^16.11.6",
"ava": "^3.15.0",
"delay": "^5.0.0",
"tsd": "^0.18.0",
"xo": "^0.45.0"
}
}

133

readme.md

@@ -1,2 +0,2 @@

# p-event [![Build Status](https://travis-ci.com/sindresorhus/p-event.svg?branch=master)](https://travis-ci.com/sindresorhus/p-event)
# p-event

@@ -7,11 +7,11 @@ > Promisify an event by waiting for it to be emitted

It's works with any event API in Node.js and the browser (using a bundler).
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 `pEvent.iterator()` method. [Observables](https://medium.com/@benlesh/learning-observable-by-building-observable-d5da57405d87) can be useful too.
If you want multiple individual events as they are emitted, you can use the `pEventIterator()` method. [Observables](https://medium.com/@benlesh/learning-observable-by-building-observable-d5da57405d87) can be useful too.
## Install
```sh
npm install p-event
```
$ npm install p-event
```

@@ -23,16 +23,14 @@ ## Usage

```js
const pEvent = require('p-event');
const emitter = require('./some-event-emitter');
import {pEvent} from 'p-event';
import emitter from './some-event-emitter';
(async () => {
try {
const result = await pEvent(emitter, 'finish');
try {
const result = await pEvent(emitter, 'finish');
// `emitter` emitted a `finish` event
console.log(result);
} catch (error) {
// `emitter` emitted an `error` event
console.error(error);
}
})();
// `emitter` emitted a `finish` event
console.log(result);
} catch (error) {
// `emitter` emitted an `error` event
console.error(error);
}
```

@@ -43,8 +41,6 @@

```js
const pEvent = require('p-event');
import {pEvent} from 'p-event';
(async () => {
await pEvent(document, 'DOMContentLoaded');
console.log('😎');
})();
await pEvent(document, 'DOMContentLoaded');
console.log('😎');
```

@@ -55,14 +51,12 @@

```js
const pEvent = require('p-event');
const emitter = require('./some-event-emitter');
import {pEventIterator} from 'p-event';
import emitter from './some-event-emitter';
(async () => {
const asyncIterator = pEvent.iterator(emitter, 'data', {
resolutionEvents: ['finish']
});
const asyncIterator = pEventIterator(emitter, 'data', {
resolutionEvents: ['finish']
});
for await (const event of asyncIterator) {
console.log(event);
}
})();
for await (const event of asyncIterator) {
console.log(event);
}
```

@@ -119,8 +113,6 @@

```js
const pEvent = require('p-event');
const emitter = require('./some-event-emitter');
import {pEvent} from 'p-event';
import emitter from './some-event-emitter';
(async () => {
const [foo, bar] = await pEvent(emitter, 'finish', {multiArgs: true});
})();
const [foo, bar] = await pEvent(emitter, 'finish', {multiArgs: true});
```

@@ -139,15 +131,13 @@

Filter function for accepting an event.
A filter function for accepting an event.
```js
const pEvent = require('p-event');
const emitter = require('./some-event-emitter');
import {pEvent} from 'p-event';
import emitter from './some-event-emitter';
(async () => {
const result = await pEvent(emitter, '🦄', value => value > 3);
// Do something with first 🦄 event with a value greater than 3
})();
const result = await pEvent(emitter, '🦄', value => value > 3);
// Do something with first 🦄 event with a value greater than 3
```
### pEvent.multiple(emitter, event, options)
### pEventMultiple(emitter, event, options)

@@ -181,7 +171,7 @@ Wait for multiple event emissions. Returns an array.

```js
const pEvent = require('p-event');
import {pEventMultiple} from 'p-event';
const emitter = new EventEmitter();
const promise = pEvent.multiple(emitter, 'hello', {
const promise = pEventMultiple(emitter, 'hello', {
resolveImmediately: true,

@@ -211,4 +201,4 @@ count: Infinity

### pEvent.iterator(emitter, event, options?)
### pEvent.iterator(emitter, event, filter)
### pEventIterator(emitter, event, options?)
### pEventIterator(emitter, event, filter)

@@ -228,3 +218,3 @@ Returns an [async iterator](https://2ality.com/2016/10/asynchronous-iteration.html) 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.

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.
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.

@@ -238,3 +228,3 @@ ##### resolutionEvents

### pEvent.TimeoutError
### TimeoutError

@@ -246,3 +236,3 @@ Exposed for instance checking and sub-classing.

```js
const pEvent = require('p-event');
import {pEvent} from 'p-event';

@@ -261,3 +251,3 @@ try {

```js
const fs = require('fs');
import fs from 'node:fs';

@@ -288,4 +278,4 @@ function getOpenReadStream(file, callback) {

```js
const fs = require('fs');
const pEvent = require('p-event');
import fs from 'node:fs';
import {pEvent} from 'p-event';

@@ -302,3 +292,4 @@ async function getOpenReadStream(file) {

stream.pipe(process.stdout);
})().catch(console.error);
})()
.catch(console.error);
```

@@ -313,21 +304,19 @@

```js
const pEvent = require('p-event');
const emitter = require('./some-event-emitter');
import {pEvent} from 'p-event';
import emitter from './some-event-emitter';
(async () => {
try {
const result = await pEvent(emitter, 'finish');
try {
const result = await pEvent(emitter, 'finish');
if (result === 'unwanted result') {
throw new Error('Emitter finished with an error');
}
if (result === 'unwanted result') {
throw new Error('Emitter finished with an error');
}
// `emitter` emitted a `finish` event with an acceptable value
console.log(result);
} catch (error) {
// `emitter` emitted an `error` event or
// emitted a `finish` with 'unwanted result'
console.error(error);
}
})();
// `emitter` emitted a `finish` event with an acceptable value
console.log(result);
} catch (error) {
// `emitter` emitted an `error` event or
// emitted a `finish` with 'unwanted result'
console.error(error);
}
```

@@ -334,0 +323,0 @@

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

About

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc