'use strict'; Object.defineProperty(exports, "__esModule", { value: true }); exports.default = function (tasks, callback) { callback = (0, _once2.default)(callback || _noop2.default); if (!(0, _isArray2.default)(tasks)) return callback(new Error('First argument to waterfall must be an array of functions')); if (!tasks.length) return callback(); var taskIndex = 0; function nextTask(args) { if (taskIndex === tasks.length) { return callback.apply(null, [null].concat(args)); } var taskCallback = (0, _onlyOnce2.default)((0, _rest2.default)(function (err, args) { if (err) { return callback.apply(null, [err].concat(args)); } nextTask(args); })); args.push(taskCallback); var task = (0, _wrapAsync2.default)(tasks[taskIndex++]); task.apply(null, args); } nextTask([]); }; var _isArray = require('lodash/isArray'); var _isArray2 = _interopRequireDefault(_isArray); var _noop = require('lodash/noop'); var _noop2 = _interopRequireDefault(_noop); var _once = require('./internal/once'); var _once2 = _interopRequireDefault(_once); var _rest = require('./internal/rest'); var _rest2 = _interopRequireDefault(_rest); var _onlyOnce = require('./internal/onlyOnce'); var _onlyOnce2 = _interopRequireDefault(_onlyOnce); var _wrapAsync = require('./internal/wrapAsync'); var _wrapAsync2 = _interopRequireDefault(_wrapAsync); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } module.exports = exports['default']; /** * Runs the `tasks` array of functions in series, each passing their results to * the next in the array. However, if any of the `tasks` pass an error to their * own callback, the next function is not executed, and the main `callback` is * immediately called with the error. * * @name waterfall * @static * @memberOf module:ControlFlow * @method * @category Control Flow * @param {Array} tasks - An array of [async functions]{@link AsyncFunction} * to run. * Each function should complete with any number of `result` values. * The `result` values will be passed as arguments, in order, to the next task. * @param {Function} [callback] - An optional callback to run once all the * functions have completed. This will be passed the results of the last task's * callback. Invoked with (err, [results]). * @returns undefined * @example * * async.waterfall([ * function(callback) { * callback(null, 'one', 'two'); * }, * function(arg1, arg2, callback) { * // arg1 now equals 'one' and arg2 now equals 'two' * callback(null, 'three'); * }, * function(arg1, callback) { * // arg1 now equals 'three' * callback(null, 'done'); * } * ], function (err, result) { * // result now equals 'done' * }); * * // Or, with named functions: * async.waterfall([ * myFirstFunction, * mySecondFunction, * myLastFunction, * ], function (err, result) { * // result now equals 'done' * }); * function myFirstFunction(callback) { * callback(null, 'one', 'two'); * } * function mySecondFunction(arg1, arg2, callback) { * // arg1 now equals 'one' and arg2 now equals 'two' * callback(null, 'three'); * } * function myLastFunction(arg1, callback) { * // arg1 now equals 'three' * callback(null, 'done'); * } */