tentakelfabrik
/
tiny-consent


								'use strict';


								Object.defineProperty(exports, "__esModule", {

								    value: true

								});


								exports.default = function (tasks, concurrency, callback) {

								    if (typeof concurrency === 'function') {

								        // concurrency is optional, shift the args.

								        callback = concurrency;

								        concurrency = null;

								    }

								    callback = (0, _once2.default)(callback || _noop2.default);

								    var keys = (0, _keys2.default)(tasks);

								    var numTasks = keys.length;

								    if (!numTasks) {

								        return callback(null);

								    }

								    if (!concurrency) {

								        concurrency = numTasks;

								    }


								    var results = {};

								    var runningTasks = 0;

								    var hasError = false;


								    var listeners = Object.create(null);


								    var readyTasks = [];


								    // for cycle detection:

								    var readyToCheck = []; // tasks that have been identified as reachable

								    // without the possibility of returning to an ancestor task

								    var uncheckedDependencies = {};


								    (0, _baseForOwn2.default)(tasks, function (task, key) {

								        if (!(0, _isArray2.default)(task)) {

								            // no dependencies

								            enqueueTask(key, [task]);

								            readyToCheck.push(key);

								            return;

								        }


								        var dependencies = task.slice(0, task.length - 1);

								        var remainingDependencies = dependencies.length;

								        if (remainingDependencies === 0) {

								            enqueueTask(key, task);

								            readyToCheck.push(key);

								            return;

								        }

								        uncheckedDependencies[key] = remainingDependencies;


								        (0, _arrayEach2.default)(dependencies, function (dependencyName) {

								            if (!tasks[dependencyName]) {

								                throw new Error('async.auto task `' + key + '` has a non-existent dependency `' + dependencyName + '` in ' + dependencies.join(', '));

								            }

								            addListener(dependencyName, function () {

								                remainingDependencies--;

								                if (remainingDependencies === 0) {

								                    enqueueTask(key, task);

								                }

								            });

								        });

								    });


								    checkForDeadlocks();

								    processQueue();


								    function enqueueTask(key, task) {

								        readyTasks.push(function () {

								            runTask(key, task);

								        });

								    }


								    function processQueue() {

								        if (readyTasks.length === 0 && runningTasks === 0) {

								            return callback(null, results);

								        }

								        while (readyTasks.length && runningTasks < concurrency) {

								            var run = readyTasks.shift();

								            run();

								        }

								    }


								    function addListener(taskName, fn) {

								        var taskListeners = listeners[taskName];

								        if (!taskListeners) {

								            taskListeners = listeners[taskName] = [];

								        }


								        taskListeners.push(fn);

								    }


								    function taskComplete(taskName) {

								        var taskListeners = listeners[taskName] || [];

								        (0, _arrayEach2.default)(taskListeners, function (fn) {

								            fn();

								        });

								        processQueue();

								    }


								    function runTask(key, task) {

								        if (hasError) return;


								        var taskCallback = (0, _onlyOnce2.default)(function (err, result) {

								            runningTasks--;

								            if (arguments.length > 2) {

								                result = (0, _slice2.default)(arguments, 1);

								            }

								            if (err) {

								                var safeResults = {};

								                (0, _baseForOwn2.default)(results, function (val, rkey) {

								                    safeResults[rkey] = val;

								                });

								                safeResults[key] = result;

								                hasError = true;

								                listeners = Object.create(null);


								                callback(err, safeResults);

								            } else {

								                results[key] = result;

								                taskComplete(key);

								            }

								        });


								        runningTasks++;

								        var taskFn = (0, _wrapAsync2.default)(task[task.length - 1]);

								        if (task.length > 1) {

								            taskFn(results, taskCallback);

								        } else {

								            taskFn(taskCallback);

								        }

								    }


								    function checkForDeadlocks() {

								        // Kahn's algorithm

								        // https://en.wikipedia.org/wiki/Topological_sorting#Kahn.27s_algorithm

								        // http://connalle.blogspot.com/2013/10/topological-sortingkahn-algorithm.html

								        var currentTask;

								        var counter = 0;

								        while (readyToCheck.length) {

								            currentTask = readyToCheck.pop();

								            counter++;

								            (0, _arrayEach2.default)(getDependents(currentTask), function (dependent) {

								                if (--uncheckedDependencies[dependent] === 0) {

								                    readyToCheck.push(dependent);

								                }

								            });

								        }


								        if (counter !== numTasks) {

								            throw new Error('async.auto cannot execute tasks due to a recursive dependency');

								        }

								    }


								    function getDependents(taskName) {

								        var result = [];

								        (0, _baseForOwn2.default)(tasks, function (task, key) {

								            if ((0, _isArray2.default)(task) && (0, _baseIndexOf2.default)(task, taskName, 0) >= 0) {

								                result.push(key);

								            }

								        });

								        return result;

								    }

								};


								var _arrayEach = require('lodash/_arrayEach');


								var _arrayEach2 = _interopRequireDefault(_arrayEach);


								var _baseForOwn = require('lodash/_baseForOwn');


								var _baseForOwn2 = _interopRequireDefault(_baseForOwn);


								var _baseIndexOf = require('lodash/_baseIndexOf');


								var _baseIndexOf2 = _interopRequireDefault(_baseIndexOf);


								var _isArray = require('lodash/isArray');


								var _isArray2 = _interopRequireDefault(_isArray);


								var _keys = require('lodash/keys');


								var _keys2 = _interopRequireDefault(_keys);


								var _noop = require('lodash/noop');


								var _noop2 = _interopRequireDefault(_noop);


								var _slice = require('./internal/slice');


								var _slice2 = _interopRequireDefault(_slice);


								var _once = require('./internal/once');


								var _once2 = _interopRequireDefault(_once);


								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'];


								/**

								 * Determines the best order for running the {@link AsyncFunction}s in `tasks`, based on

								 * their requirements. Each function can optionally depend on other functions

								 * being completed first, and each function is run as soon as its requirements

								 * are satisfied.

								 *

								 * If any of the {@link AsyncFunction}s pass an error to their callback, the `auto` sequence

								 * will stop. Further tasks will not execute (so any other functions depending

								 * on it will not run), and the main `callback` is immediately called with the

								 * error.

								 *

								 * {@link AsyncFunction}s also receive an object containing the results of functions which

								 * have completed so far as the first argument, if they have dependencies. If a

								 * task function has no dependencies, it will only be passed a callback.

								 *

								 * @name auto

								 * @static

								 * @memberOf module:ControlFlow

								 * @method

								 * @category Control Flow

								 * @param {Object} tasks - An object. Each of its properties is either a

								 * function or an array of requirements, with the {@link AsyncFunction} itself the last item

								 * in the array. The object's key of a property serves as the name of the task

								 * defined by that property, i.e. can be used when specifying requirements for

								 * other tasks. The function receives one or two arguments:

								 * * a `results` object, containing the results of the previously executed

								 *   functions, only passed if the task has any dependencies,

								 * * a `callback(err, result)` function, which must be called when finished,

								 *   passing an `error` (which can be `null`) and the result of the function's

								 *   execution.

								 * @param {number} [concurrency=Infinity] - An optional `integer` for

								 * determining the maximum number of tasks that can be run in parallel. By

								 * default, as many as possible.

								 * @param {Function} [callback] - An optional callback which is called when all

								 * the tasks have been completed. It receives the `err` argument if any `tasks`

								 * pass an error to their callback. Results are always returned; however, if an

								 * error occurs, no further `tasks` will be performed, and the results object

								 * will only contain partial results. Invoked with (err, results).

								 * @returns undefined

								 * @example

								 *

								 * async.auto({

								 *     // this function will just be passed a callback

								 *     readData: async.apply(fs.readFile, 'data.txt', 'utf-8'),

								 *     showData: ['readData', function(results, cb) {

								 *         // results.readData is the file's contents

								 *         // ...

								 *     }]

								 * }, callback);

								 *

								 * async.auto({

								 *     get_data: function(callback) {

								 *         console.log('in get_data');

								 *         // async code to get some data

								 *         callback(null, 'data', 'converted to array');

								 *     },

								 *     make_folder: function(callback) {

								 *         console.log('in make_folder');

								 *         // async code to create a directory to store a file in

								 *         // this is run at the same time as getting the data

								 *         callback(null, 'folder');

								 *     },

								 *     write_file: ['get_data', 'make_folder', function(results, callback) {

								 *         console.log('in write_file', JSON.stringify(results));

								 *         // once there is some data and the directory exists,

								 *         // write the data to a file in the directory

								 *         callback(null, 'filename');

								 *     }],

								 *     email_link: ['write_file', function(results, callback) {

								 *         console.log('in email_link', JSON.stringify(results));

								 *         // once the file is written let's email a link to it...

								 *         // results.write_file contains the filename returned by write_file.

								 *         callback(null, {'file':results.write_file, 'email':'user@example.com'});

								 *     }]

								 * }, function(err, results) {

								 *     console.log('err = ', err);

								 *     console.log('results = ', results);

								 * });

								 */