HORIZON PROJECT

'use strict';

Object.defineProperty(exports, "__esModule", {

    value: true

});

exports.default = timeout;

var _initialParams = require('./internal/initialParams');

var _initialParams2 = _interopRequireDefault(_initialParams);

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

/**

 * Sets a time limit on an asynchronous function. If the function does not call

 * its callback within the specified milliseconds, it will be called with a

 * timeout error. The code property for the error object will be `'ETIMEDOUT'`.

 *

 * @name timeout

 * @static

 * @memberOf module:Utils

 * @method

 * @category Util

 * @param {Function} asyncFn - The asynchronous function you want to set the

 * time limit.

 * @param {number} milliseconds - The specified time limit.

 * @param {*} [info] - Any variable you want attached (`string`, `object`, etc)

 * to timeout Error for more information..

 * @returns {Function} Returns a wrapped function that can be used with any of

 * the control flow functions. Invoke this function with the same

 * parameters as you would `asyncFunc`.

 * @example

 *

 * function myFunction(foo, callback) {

 *     doAsyncTask(foo, function(err, data) {

 *         // handle errors

 *         if (err) return callback(err);

 *

 *         // do some stuff ...

 *

 *         // return processed data

 *         return callback(null, data);

 *     });

 * }

 *

 * var wrapped = async.timeout(myFunction, 1000);

 *

 * // call `wrapped` as you would `myFunction`

 * wrapped({ bar: 'bar' }, function(err, data) {

 *     // if `myFunction` takes < 1000 ms to execute, `err`

 *     // and `data` will have their expected values

 *

 *     // else `err` will be an Error with the code 'ETIMEDOUT'

 * });

 */

function timeout(asyncFn, milliseconds, info) {

    var originalCallback, timer;

    var timedOut = false;

    function injectedCallback() {

        if (!timedOut) {

            originalCallback.apply(null, arguments);

            clearTimeout(timer);

        }

    }

    function timeoutCallback() {

        var name = asyncFn.name || 'anonymous';

        var error = new Error('Callback function "' + name + '" timed out.');

        error.code = 'ETIMEDOUT';

        if (info) {

            error.info = info;

        }

        timedOut = true;

        originalCallback(error);

    }

    return (0, _initialParams2.default)(function (args, origCallback) {

        originalCallback = origCallback;

        // setup timer and call original function

        timer = setTimeout(timeoutCallback, milliseconds);

        asyncFn.apply(null, args.concat(injectedCallback));

    });

}

module.exports = exports['default'];