FM / async

/usr/local/lib/node_modules/pm2/node_modules/@pm2/js-api/node_modules/async/

/usr/local/lib/node_modules/pm2/node_modules/@pm2/js-api/node_modules/async

Name	Size	Mode	Actions
dist/	-	0755	rm
internal/	-	0755	rm
all.js	1680	0644	edit dl rm
allLimit.js	1545	0644	edit dl rm
allSeries.js	1275	0644	edit dl rm
any.js	1758	0644	edit dl rm
anyLimit.js	1592	0644	edit dl rm
anySeries.js	1314	0644	edit dl rm
apply.js	1843	0644	edit dl rm
applyEach.js	1779	0644	edit dl rm
applyEachSeries.js	1285	0644	edit dl rm
asyncify.js	3500	0644	edit dl rm
auto.js	9844	0644	edit dl rm
autoInject.js	6481	0644	edit dl rm
bower.json	245	0644	edit dl rm
cargo.js	4651	0644	edit dl rm
CHANGELOG.md	29340	0644	edit dl rm
compose.js	1561	0644	edit dl rm
concat.js	1588	0644	edit dl rm
concatLimit.js	2162	0644	edit dl rm
concatSeries.js	1272	0644	edit dl rm
constant.js	1760	0644	edit dl rm
detect.js	2208	0644	edit dl rm
detectLimit.js	1760	0644	edit dl rm
detectSeries.js	1353	0644	edit dl rm
dir.js	1294	0644	edit dl rm
doDuring.js	2183	0644	edit dl rm
doUntil.js	1374	0644	edit dl rm
doWhilst.js	2064	0644	edit dl rm
during.js	2201	0644	edit dl rm
each.js	2836	0644	edit dl rm
eachLimit.js	1568	0644	edit dl rm
eachOf.js	3368	0644	edit dl rm
eachOfLimit.js	1418	0644	edit dl rm
eachOfSeries.js	1137	0644	edit dl rm
eachSeries.js	1206	0644	edit dl rm
ensureAsync.js	2515	0644	edit dl rm
every.js	1680	0644	edit dl rm
everyLimit.js	1545	0644	edit dl rm
everySeries.js	1275	0644	edit dl rm
filter.js	1524	0644	edit dl rm
filterLimit.js	1344	0644	edit dl rm
filterSeries.js	1236	0644	edit dl rm
find.js	2208	0644	edit dl rm
findLimit.js	1760	0644	edit dl rm
findSeries.js	1353	0644	edit dl rm
foldl.js	2676	0644	edit dl rm
foldr.js	1536	0644	edit dl rm
forEach.js	2836	0644	edit dl rm
forEachLimit.js	1568	0644	edit dl rm
forEachOf.js	3368	0644	edit dl rm
forEachOfLimit.js	1418	0644	edit dl rm
forEachOfSeries.js	1137	0644	edit dl rm
forEachSeries.js	1206	0644	edit dl rm
forever.js	1941	0644	edit dl rm
groupBy.js	2131	0644	edit dl rm
groupByLimit.js	2379	0644	edit dl rm
groupBySeries.js	1347	0644	edit dl rm
index.js	19503	0644	edit dl rm
inject.js	2676	0644	edit dl rm
LICENSE	1063	0644	edit dl rm
log.js	1194	0644	edit dl rm
map.js	2081	0644	edit dl rm
mapLimit.js	1314	0644	edit dl rm
mapSeries.js	1209	0644	edit dl rm
mapValues.js	2241	0644	edit dl rm
mapValuesLimit.js	2037	0644	edit dl rm
mapValuesSeries.js	1328	0644	edit dl rm
memoize.js	3232	0644	edit dl rm
nextTick.js	1447	0644	edit dl rm
package.json	2412	0644	edit dl rm
parallel.js	3100	0644	edit dl rm
parallelLimit.js	1422	0644	edit dl rm
priorityQueue.js	3104	0644	edit dl rm
queue.js	5855	0644	edit dl rm
race.js	2162	0644	edit dl rm
README.md	2536	0644	edit dl rm
reduce.js	2676	0644	edit dl rm
reduceRight.js	1536	0644	edit dl rm
reflect.js	2379	0644	edit dl rm
reflectAll.js	2795	0644	edit dl rm
reject.js	1448	0644	edit dl rm
rejectLimit.js	1266	0644	edit dl rm
rejectSeries.js	1158	0644	edit dl rm
retry.js	5435	0644	edit dl rm
retryable.js	2025	0644	edit dl rm
select.js	1524	0644	edit dl rm
selectLimit.js	1344	0644	edit dl rm
selectSeries.js	1236	0644	edit dl rm
seq.js	2986	0644	edit dl rm
series.js	2937	0644	edit dl rm
setImmediate.js	1389	0644	edit dl rm
some.js	1758	0644	edit dl rm
someLimit.js	1592	0644	edit dl rm
someSeries.js	1314	0644	edit dl rm
sortBy.js	2829	0644	edit dl rm
timeout.js	2776	0644	edit dl rm
times.js	1459	0644	edit dl rm
timesLimit.js	1393	0644	edit dl rm
timesSeries.js	1021	0644	edit dl rm
transform.js	2715	0644	edit dl rm
tryEach.js	2560	0644	edit dl rm
unmemoize.js	681	0644	edit dl rm
until.js	1446	0644	edit dl rm
waterfall.js	3343	0644	edit dl rm
whilst.js	2191	0644	edit dl rm
wrapSync.js	3500	0644	edit dl rm

Edit: /usr/local/lib/node_modules/pm2/node_modules/@pm2/js-api/node_modules/async/auto.js (9844B)

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

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);
        }
    }

if (counter !== numTasks) {
            throw new Error('async.auto cannot execute tasks due to a recursive dependency');
        }
    }

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);
 * });
 */

cmd: