function runTask(key, task) {
if (hasError) return;
var taskCallback = onlyOnce(rest(function(err, args) {
runningTasks--;
if (args.length <= 1) {
args = args[0];
}
if (err) {
var safeResults = {};
forOwn(results, function(val, rkey) {
safeResults[rkey] = val;
});
safeResults[key] = args;
hasError = true;
listeners = [];
callback(err, safeResults);
} else {
results[key] = args;
taskComplete(key);
}
}));
runningTasks++;
var taskFn = task[task.length - 1];
if (task.length > 1) {
taskFn(results, taskCallback);
} else {
taskFn(taskCallback);
}
}
export default function whilst(test, iteratee, cb) {
cb = cb || noop;
if (!test()) return cb(null);
var next = rest(function(err, args) {
if (err) return cb(err);
if (test.apply(this, args)) return iteratee(next);
cb.apply(null, [null].concat(args));
});
iteratee(next);
}
/**
* Repeatedly call `fn`, while `test` returns `true`. Calls `callback` when
* stopped, or an error occurs.
*
* @name whilst
* @static
* @memberOf module:ControlFlow
* @method
* @category Control Flow
* @param {Function} test - synchronous truth test to perform before each
* execution of `fn`. Invoked with ().
* @param {Function} iteratee - A function which is called each time `test` passes.
* The function is passed a `callback(err)`, which must be called once it has
* completed with an optional `err` argument. Invoked with (callback).
* @param {Function} [callback] - A callback which is called after the test
* function has failed and repeated execution of `fn` has stopped. `callback`
* will be passed an error and any arguments passed to the final `fn`'s
* callback. Invoked with (err, [results]);
* @returns undefined
* @example
*
* var count = 0;
* async.whilst(
* function() { return count < 5; },
* function(callback) {
* count++;
* setTimeout(function() {
* callback(null, count);
* }, 1000);
* },
* function (err, n) {
* // 5 seconds have passed, n = 5
* }
* );
*/
export default function whilst(test, iteratee, callback) {
callback = onlyOnce(callback || noop);
if (!test()) return callback(null);
var next = rest(function(err, args) {
if (err) return callback(err);
if (test()) return iteratee(next);
callback.apply(null, [null].concat(args));
});
iteratee(next);
}
function nextTask(args) {
if (taskIndex === tasks.length) {
return cb.apply(null, [null].concat(args));
}
var taskCallback = onlyOnce(rest(function(err, args) {
if (err) {
return cb.apply(null, [err].concat(args));
}
nextTask(args);
}));
args.push(taskCallback);
var task = tasks[taskIndex++];
task.apply(null, args);
}
export default function applyEach(eachfn) {
return rest(function(fns, args) {
var go = initialParams(function(args, callback) {
var that = this;
return eachfn(fns, function (fn, _, cb) {
fn.apply(that, args.concat([cb]));
},
callback);
});
if (args.length) {
return go.apply(this, args);
}
else {
return go;
}
});
}
export default function ensureAsync(fn) {
return rest(function (args) {
var callback = args.pop();
var sync = true;
args.push(function () {
var innerArgs = arguments;
if (sync) {
setImmediate(function () {
callback.apply(null, innerArgs);
});
} else {
callback.apply(null, innerArgs);
}
});
fn.apply(this, args);
sync = false;
});
}
var memoized = initialParams(function memoized(args, callback) {
var key = hasher.apply(null, args);
if (has(memo, key)) {
setImmediate(function() {
callback.apply(null, memo[key]);
});
} else if (has(queues, key)) {
queues[key].push(callback);
} else {
queues[key] = [callback];
fn.apply(null, args.concat([rest(function(args) {
memo[key] = args;
var q = queues[key];
delete queues[key];
for (var i = 0, l = q.length; i < l; i++) {
q[i].apply(null, args);
}
})]));
}
});
export default function asyncify(func) {
return rest(function (args) {
var callback = args.pop();
var result;
try {
result = func.apply(this, args);
} catch (e) {
return callback(e);
}
// if result is Promise object
if (isObject(result) && typeof result.then === 'function') {
result.then(function(value) {
callback(null, value);
})['catch'](function(err) {
callback(err.message ? err : new Error(err));
});
} else {
callback(null, result);
}
});
}
return initialParams(function reflectOn(args, reflectCallback) {
args.push(rest(function callback(err, cbArgs) {
if (err) {
reflectCallback(null, {
error: err
});
} else {
var value = null;
if (cbArgs.length === 1) {
value = cbArgs[0];
} else if (cbArgs.length > 1) {
value = cbArgs;
}
reflectCallback(null, {
value: value
});
}
}));
return fn.apply(this, args);
});
export default rest(function seq(functions) {
return rest(function(args) {
var that = this;
var cb = args[args.length - 1];
if (typeof cb == 'function') {
args.pop();
} else {
cb = noop;
}
reduce(functions, args, function(newargs, fn, cb) {
fn.apply(that, newargs.concat([rest(function(err, nextargs) {
cb(err, nextargs);
})]));
},
function(err, results) {
cb.apply(that, [err].concat(results));
});
});
})
export default rest(function(fn, args) {
return rest(function(callArgs) {
return fn.apply(null, args.concat(callArgs));
});
});
* function (value, next) {
* // value === 42
* },
* //...
* ], callback);
*
* async.waterfall([
* async.constant(filename, "utf8"),
* fs.readFile,
* function (fileData, next) {
* //...
* }
* //...
* ], callback);
*
* async.auto({
* hostname: async.constant("https://server.net/"),
* port: findFreePort,
* launchServer: ["hostname", "port", function (options, cb) {
* startServer(options, cb);
* }],
* //...
* }, callback);
*/
export default rest(function(values) {
var args = [null].concat(values);
return initialParams(function (ignoredArgs, callback) {
return callback.apply(this, args);
});
});
reduce(fns, args, function(newargs, fn, cb) {
fn.apply(that, newargs.concat([rest(function(err, nextargs) {
cb(err, nextargs);
})]));
},