FM / p-event

/var/www/cobraambalaj/node_modules/p-event/

/var/www/cobraambalaj/node_modules/p-event

Name	Size	Mode	Actions
index.d.ts	8726	0644	edit dl rm
index.js	6049	0644	edit dl rm
license	1117	0644	edit dl rm
package.json	1980	0644	edit dl rm
readme.md	7888	0644	edit dl rm

Edit: /var/www/cobraambalaj/node_modules/p-event/index.js (6049B)

'use strict';
const pTimeout = require('p-timeout');

const symbolAsyncIterator = Symbol.asyncIterator || '@@asyncIterator';

const normalizeEmitter = emitter => {
	const addListener = emitter.on || emitter.addListener || emitter.addEventListener;
	const removeListener = emitter.off || emitter.removeListener || emitter.removeEventListener;

if (!addListener || !removeListener) {
		throw new TypeError('Emitter is not compatible');
	}

return {
		addListener: addListener.bind(emitter),
		removeListener: removeListener.bind(emitter)
	};
};

const toArray = value => Array.isArray(value) ? value : [value];

const multiple = (emitter, event, options) => {
	let cancel;
	const ret = new Promise((resolve, reject) => {
		options = {
			rejectionEvents: ['error'],
			multiArgs: false,
			resolveImmediately: false,
			...options
		};

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

// Allow multiple events
		const events = toArray(event);

const items = [];
		const {addListener, removeListener} = normalizeEmitter(emitter);

const onItem = (...args) => {
			const value = options.multiArgs ? args : args[0];

if (options.filter && !options.filter(value)) {
				return;
			}

items.push(value);

if (options.count === items.length) {
				cancel();
				resolve(items);
			}
		};

const rejectHandler = error => {
			cancel();
			reject(error);
		};

cancel = () => {
			for (const event of events) {
				removeListener(event, onItem);
			}

for (const rejectionEvent of options.rejectionEvents) {
				removeListener(rejectionEvent, rejectHandler);
			}
		};

for (const event of events) {
			addListener(event, onItem);
		}

for (const rejectionEvent of options.rejectionEvents) {
			addListener(rejectionEvent, rejectHandler);
		}

if (options.resolveImmediately) {
			resolve(items);
		}
	});

ret.cancel = cancel;

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

return ret;
};

const pEvent = (emitter, event, options) => {
	if (typeof options === 'function') {
		options = {filter: options};
	}

options = {
		...options,
		count: 1,
		resolveImmediately: false
	};

const arrayPromise = multiple(emitter, event, options);
	const promise = arrayPromise.then(array => array[0]); // eslint-disable-line promise/prefer-await-to-then
	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) => {
	if (typeof options === 'function') {
		options = {filter: options};
	}

// Allow multiple events
	const events = toArray(event);

options = {
		rejectionEvents: ['error'],
		resolutionEvents: [],
		limit: Infinity,
		multiArgs: false,
		...options
	};

const {limit} = options;
	const isValidLimit = limit >= 0 && (limit === Infinity || Number.isInteger(limit));
	if (!isValidLimit) {
		throw new TypeError('The `limit` option should be a non-negative integer or Infinity');
	}

if (limit === 0) {
		// Return an empty async iterator to avoid any further cost
		return {
			[Symbol.asyncIterator]() {
				return this;
			},
			async next() {
				return {
					done: true,
					value: undefined
				};
			}
		};
	}

const {addListener, removeListener} = normalizeEmitter(emitter);

let isDone = false;
	let error;
	let hasPendingError = false;
	const nextQueue = [];
	const valueQueue = [];
	let eventCount = 0;
	let isLimitReached = false;

const valueHandler = (...args) => {
		eventCount++;
		isLimitReached = eventCount === limit;

const value = options.multiArgs ? args : args[0];

if (nextQueue.length > 0) {
			const {resolve} = nextQueue.shift();

resolve({done: false, value});

if (isLimitReached) {
				cancel();
			}

return;
		}

valueQueue.push(value);

if (isLimitReached) {
			cancel();
		}
	};

const cancel = () => {
		isDone = true;
		for (const event of events) {
			removeListener(event, valueHandler);
		}

for (const rejectionEvent of options.rejectionEvents) {
			removeListener(rejectionEvent, rejectHandler);
		}

for (const resolutionEvent of options.resolutionEvents) {
			removeListener(resolutionEvent, resolveHandler);
		}

while (nextQueue.length > 0) {
			const {resolve} = nextQueue.shift();
			resolve({done: true, value: undefined});
		}
	};

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

if (nextQueue.length > 0) {
			const {reject} = nextQueue.shift();
			reject(error);
		} else {
			hasPendingError = true;
		}

cancel();
	};

const resolveHandler = (...args) => {
		const value = options.multiArgs ? args : args[0];

if (options.filter && !options.filter(value)) {
			return;
		}

if (nextQueue.length > 0) {
			const {resolve} = nextQueue.shift();
			resolve({done: true, value});
		} else {
			valueQueue.push(value);
		}

cancel();
	};

for (const event of events) {
		addListener(event, valueHandler);
	}

for (const rejectionEvent of options.rejectionEvents) {
		addListener(rejectionEvent, rejectHandler);
	}

for (const resolutionEvent of options.resolutionEvents) {
		addListener(resolutionEvent, resolveHandler);
	}

return {
		[symbolAsyncIterator]() {
			return this;
		},
		async next() {
			if (valueQueue.length > 0) {
				const value = valueQueue.shift();
				return {
					done: isDone && valueQueue.length === 0 && !isLimitReached,
					value
				};
			}

if (hasPendingError) {
				hasPendingError = false;
				throw error;
			}

if (isDone) {
				return {
					done: true,
					value: undefined
				};
			}

return new Promise((resolve, reject) => nextQueue.push({resolve, reject}));
		},
		async return(value) {
			cancel();
			return {
				done: isDone,
				value
			};
		}
	};
};

module.exports.TimeoutError = pTimeout.TimeoutError;

cmd: