'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.default = timeout;
  
  var _initialParams = require('./internal/initialParams');
  
  var _initialParams2 = _interopRequireDefault(_initialParams);
  
  var _wrapAsync = require('./internal/wrapAsync');
  
  var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
  
  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 {AsyncFunction} asyncFn - The async function to limit in time.
   * @param {number} milliseconds - The specified time limit.
   * @param {*} [info] - Any variable you want attached (`string`, `object`, etc)
   * to timeout Error for more information..
   * @returns {AsyncFunction} 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);
      }
  
      var fn = (0, _wrapAsync2.default)(asyncFn);
  
      return (0, _initialParams2.default)(function (args, origCallback) {
          originalCallback = origCallback;
          // setup timer and call original function
          timer = setTimeout(timeoutCallback, milliseconds);
          fn.apply(null, args.concat(injectedCallback));
      });
  }
  module.exports = exports['default'];