| Server IP : 199.250.214.225 / Your IP : 18.189.195.251 Web Server : Apache System : Linux vps64074.inmotionhosting.com 3.10.0-1160.105.1.vz7.214.3 #1 SMP Tue Jan 9 19:45:01 MSK 2024 x86_64 User : nicngo5 ( 1001) PHP Version : 7.4.33 Disable Function : exec,passthru,shell_exec,system MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : OFF Directory : /home/nicngo5/funds.upgrade.nicn.gov.ng/funds-upgraded/node_modules/p-event/ |
Upload File : |
'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;