tentakelfabrik
/
tiny-consent


								'use strict';


								Object.defineProperty(exports, "__esModule", {

								    value: true

								});

								exports.default = autoInject;


								var _auto = require('./auto');


								var _auto2 = _interopRequireDefault(_auto);


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


								var _baseForOwn2 = _interopRequireDefault(_baseForOwn);


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


								var _arrayMap2 = _interopRequireDefault(_arrayMap);


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


								var _isArray2 = _interopRequireDefault(_isArray);


								var _trim = require('lodash/trim');


								var _trim2 = _interopRequireDefault(_trim);


								var _wrapAsync = require('./internal/wrapAsync');


								var _wrapAsync2 = _interopRequireDefault(_wrapAsync);


								function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }


								var FN_ARGS = /^(?:async\s+)?(function)?\s*[^\(]*\(\s*([^\)]*)\)/m;

								var FN_ARG_SPLIT = /,/;

								var FN_ARG = /(=.+)?(\s*)$/;

								var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;


								function parseParams(func) {

								    func = func.toString().replace(STRIP_COMMENTS, '');

								    func = func.match(FN_ARGS)[2].replace(' ', '');

								    func = func ? func.split(FN_ARG_SPLIT) : [];

								    func = func.map(function (arg) {

								        return (0, _trim2.default)(arg.replace(FN_ARG, ''));

								    });

								    return func;

								}


								/**

								 * A dependency-injected version of the [async.auto]{@link module:ControlFlow.auto} function. Dependent

								 * tasks are specified as parameters to the function, after the usual callback

								 * parameter, with the parameter names matching the names of the tasks it

								 * depends on. This can provide even more readable task graphs which can be

								 * easier to maintain.

								 *

								 * If a final callback is specified, the task results are similarly injected,

								 * specified as named parameters after the initial error parameter.

								 *

								 * The autoInject function is purely syntactic sugar and its semantics are

								 * otherwise equivalent to [async.auto]{@link module:ControlFlow.auto}.

								 *

								 * @name autoInject

								 * @static

								 * @memberOf module:ControlFlow

								 * @method

								 * @see [async.auto]{@link module:ControlFlow.auto}

								 * @category Control Flow

								 * @param {Object} tasks - An object, each of whose properties is an {@link AsyncFunction} of

								 * the form 'func([dependencies...], callback). 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 `callback` parameter is a `callback(err, result)` which must be called

								 *   when finished, passing an `error` (which can be `null`) and the result of

								 *   the function's execution. The remaining parameters name other tasks on

								 *   which the task is dependent, and the results from those tasks are the

								 *   arguments of those parameters.

								 * @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, and a `results` object with any completed

								 * task results, similar to `auto`.

								 * @example

								 *

								 * //  The example from `auto` can be rewritten as follows:

								 * async.autoInject({

								 *     get_data: function(callback) {

								 *         // async code to get some data

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

								 *     },

								 *     make_folder: function(callback) {

								 *         // 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: function(get_data, make_folder, callback) {

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

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

								 *         callback(null, 'filename');

								 *     },

								 *     email_link: function(write_file, callback) {

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

								 *         // write_file contains the filename returned by write_file.

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

								 *     }

								 * }, function(err, results) {

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

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

								 * });

								 *

								 * // If you are using a JS minifier that mangles parameter names, `autoInject`

								 * // will not work with plain functions, since the parameter names will be

								 * // collapsed to a single letter identifier.  To work around this, you can

								 * // explicitly specify the names of the parameters your task function needs

								 * // in an array, similar to Angular.js dependency injection.

								 *

								 * // This still has an advantage over plain `auto`, since the results a task

								 * // depends on are still spread into arguments.

								 * async.autoInject({

								 *     //...

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

								 *         callback(null, 'filename');

								 *     }],

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

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

								 *     }]

								 *     //...

								 * }, function(err, results) {

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

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

								 * });

								 */

								function autoInject(tasks, callback) {

								    var newTasks = {};


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

								        var params;

								        var fnIsAsync = (0, _wrapAsync.isAsync)(taskFn);

								        var hasNoDeps = !fnIsAsync && taskFn.length === 1 || fnIsAsync && taskFn.length === 0;


								        if ((0, _isArray2.default)(taskFn)) {

								            params = taskFn.slice(0, -1);

								            taskFn = taskFn[taskFn.length - 1];


								            newTasks[key] = params.concat(params.length > 0 ? newTask : taskFn);

								        } else if (hasNoDeps) {

								            // no dependencies, use the function as-is

								            newTasks[key] = taskFn;

								        } else {

								            params = parseParams(taskFn);

								            if (taskFn.length === 0 && !fnIsAsync && params.length === 0) {

								                throw new Error("autoInject task functions require explicit parameters.");

								            }


								            // remove callback param

								            if (!fnIsAsync) params.pop();


								            newTasks[key] = params.concat(newTask);

								        }


								        function newTask(results, taskCb) {

								            var newArgs = (0, _arrayMap2.default)(params, function (name) {

								                return results[name];

								            });

								            newArgs.push(taskCb);

								            (0, _wrapAsync2.default)(taskFn).apply(null, newArgs);

								        }

								    });


								    (0, _auto2.default)(newTasks, callback);

								}

								module.exports = exports['default'];