| Server IP : 167.235.224.122 / Your IP : 216.73.216.110 Web Server : Apache/2.4.58 (Ubuntu) System : Linux newplayground 6.8.0-136-generic #136-Ubuntu SMP PREEMPT_DYNAMIC Wed Jul 1 21:33:11 UTC 2026 aarch64 User : deploy ( 1000) PHP Version : 8.4.23 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /var/www/html/jungly/node_modules/tryer/src/ |
Upload File : |
// Conditional and repeated task invocation for node and browser.
/*globals setTimeout, define, module */
(function (globals) {
'use strict';
if (typeof define === 'function' && define.amd) {
define(function () {
return tryer;
});
} else if (typeof module !== 'undefined' && module !== null) {
module.exports = tryer;
} else {
globals.tryer = tryer;
}
// Public function `tryer`.
//
// Performs some action when pre-requisite conditions are met and/or until
// post-requisite conditions are satisfied.
//
// @option action {function} The function that you want to invoke. Defaults to `() => {}`.
// If `action` returns a promise, iterations will not end until
// the promise is resolved or rejected. Alternatively, `action`
// may take a callback argument, `done`, to signal that it is
// asynchronous. In that case, you are responsible for calling
// `done` when the action is finished.
//
// @option when {function} Predicate used to test pre-conditions. Should return `false`
// to postpone `action` or `true` to perform it. Defaults to
// `() => true`.
//
// @option until {function} Predicate used to test post-conditions. Should return `false`
// to retry `action` or `true` to terminate it. Defaults to
// `() => true`.
//
// @option fail {function} Callback to be invoked if `limit` tries are reached. Defaults
// to `() => {}`.
//
// @option pass {function} Callback to be invoked after `until` has returned truthily.
// Defaults to `() => {}`.
//
// @option interval {number} Retry interval in milliseconds. A negative number indicates
// that subsequent retries should wait for double the interval
// from the preceding iteration (exponential backoff). Defaults
// to -1000.
//
// @option limit {number} Maximum retry count, at which point the call fails and retries
// will cease. A negative number indicates that retries should
// continue indefinitely. Defaults to -1.
//
// @example
// tryer({
// when: () => db.isConnected,
// action: () => db.insert(user),
// fail () {
// log.error('No database connection, terminating.');
// process.exit(1);
// },
// interval: 1000,
// limit: 10
// });
//
// @example
// let sent = false;
// tryer({
// until: () => sent,
// action: done => {
// smtp.send(email, error => {
// if (! error) {
// sent = true;
// }
// done();
// });
// },
// pass: next,
// interval: -1000,
// limit: -1
// });
function tryer (options) {
options = normaliseOptions(options);
iterateWhen();
function iterateWhen () {
if (preRecur()) {
iterateUntil();
}
}
function preRecur () {
return conditionallyRecur('when', iterateWhen);
}
function conditionallyRecur (predicateKey, iterate) {
if (! options[predicateKey]()) {
incrementCount(options);
if (shouldFail(options)) {
options.fail();
} else {
recur(iterate, postIncrementInterval(options));
}
return false;
}
return true;
}
function iterateUntil () {
var result;
if (isActionSynchronous(options)) {
result = options.action();
if (result && isFunction(result.then)) {
return result.then(postRecur, postRecur);
}
return postRecur();
}
options.action(postRecur);
}
function postRecur () {
if (conditionallyRecur('until', iterateUntil)) {
options.pass();
}
}
}
function normaliseOptions (options) {
options = options || {};
return {
count: 0,
when: normalisePredicate(options.when),
until: normalisePredicate(options.until),
action: normaliseFunction(options.action),
fail: normaliseFunction(options.fail),
pass: normaliseFunction(options.pass),
interval: normaliseNumber(options.interval, -1000),
limit: normaliseNumber(options.limit, -1)
};
}
function normalisePredicate (fn) {
return normalise(fn, isFunction, yes);
}
function isFunction (fn) {
return typeof fn === 'function';
}
function yes () {
return true;
}
function normaliseFunction (fn) {
return normalise(fn, isFunction, nop);
}
function nop () {
}
function normalise (thing, predicate, defaultValue) {
if (predicate(thing)) {
return thing;
}
return defaultValue;
}
function normaliseNumber (number, defaultNumber) {
return normalise(number, isNumber, defaultNumber);
}
function isNumber (number) {
return typeof number === 'number' && number === number;
}
function isActionSynchronous (options) {
return options.action.length === 0;
}
function incrementCount (options) {
options.count += 1;
}
function shouldFail (options) {
return options.limit >= 0 && options.count >= options.limit;
}
function postIncrementInterval (options) {
var currentInterval = options.interval;
if (options.interval < 0) {
options.interval *= 2;
}
return currentInterval;
}
function recur (fn, interval) {
setTimeout(fn, Math.abs(interval));
}
}(this));