@oxog/delay
Version:
A comprehensive, zero-dependency delay/timeout utility library with advanced timing features
99 lines • 3.7 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.raceWithTimeout = raceWithTimeout;
exports.createTimeoutPromise = createTimeoutPromise;
exports.minimumDelay = minimumDelay;
exports.raceArray = raceArray;
exports.createDelayedPromise = createDelayedPromise;
exports.sequential = sequential;
exports.parallel = parallel;
const index_js_1 = require("../types/index.js");
const delay_js_1 = require("../core/delay.js");
async function raceWithTimeout(promises, timeoutMs, timeoutError) {
const timeoutPromise = createTimeoutPromise(timeoutMs, timeoutError);
try {
const result = await Promise.race([...promises, timeoutPromise]);
return result;
}
catch (error) {
throw error;
}
}
function createTimeoutPromise(ms, error) {
return new Promise((_, reject) => {
setTimeout(() => {
const timeoutError = error || new index_js_1.DelayError(`Operation timed out after ${ms}ms`, index_js_1.DelayErrorCode.TIMEOUT, { timeout: ms });
reject(timeoutError);
}, ms);
});
}
async function minimumDelay(promise, minMs) {
const [result] = await Promise.all([
promise,
(0, delay_js_1.createBasicDelay)(minMs),
]);
return result;
}
async function raceArray(promises, options = {}) {
const { timeout, timeoutError, failFast = true } = options;
if (promises.length === 0) {
throw new index_js_1.DelayError('Cannot race empty array of promises', index_js_1.DelayErrorCode.INVALID_OPTIONS, { promises: [] });
}
const racePromises = [...promises];
if (timeout !== undefined) {
racePromises.push(createTimeoutPromise(timeout, timeoutError));
}
if (failFast) {
return Promise.race(racePromises);
}
// If not fail-fast, wait for the first successful result
return new Promise((resolve, reject) => {
let rejectionCount = 0;
const errors = [];
racePromises.forEach((promise, index) => {
promise
.then(result => resolve(result))
.catch(error => {
errors[index] = error;
rejectionCount++;
if (rejectionCount === racePromises.length) {
reject(new index_js_1.DelayError('All promises rejected', index_js_1.DelayErrorCode.RETRY_EXHAUSTED, { errors }));
}
});
});
});
}
function createDelayedPromise(factory, delayMs) {
return (0, delay_js_1.createBasicDelay)(delayMs).then(() => factory());
}
async function sequential(factories, delayBetween = 0) {
const results = [];
for (let i = 0; i < factories.length; i++) {
if (i > 0 && delayBetween > 0) {
await (0, delay_js_1.createBasicDelay)(delayBetween);
}
const result = await factories[i]();
results.push(result);
}
return results;
}
async function parallel(factories, concurrency = Infinity) {
if (concurrency <= 0) {
throw new index_js_1.DelayError('Concurrency must be positive', index_js_1.DelayErrorCode.INVALID_OPTIONS, { concurrency });
}
if (concurrency >= factories.length) {
return Promise.all(factories.map(factory => factory()));
}
const results = new Array(factories.length);
let index = 0;
const worker = async () => {
while (index < factories.length) {
const currentIndex = index++;
results[currentIndex] = await factories[currentIndex]();
}
};
const workers = Array.from({ length: Math.min(concurrency, factories.length) }, worker);
await Promise.all(workers);
return results;
}
//# sourceMappingURL=promise.js.map