jira-precommit-hook/lib/promise-utils.js

Git commit hook to verify commit messages are tagged with a JIRA issue number

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.anyPromise = undefined;

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var anyPromise = exports.anyPromise = function () {
  var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2(arrayOfPromises) {
    var resolve, reject, result, rejects;
    return _regenerator2.default.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            if (!(arrayOfPromises === undefined)) {
              _context2.next = 2;
              break;
            }

            throw new Error('No arguments provided');

          case 2:
            if (!(!(arrayOfPromises instanceof Array) || arrayOfPromises.length === 0)) {
              _context2.next = 4;
              break;
            }

            throw new Error('Argument is not a non-array');

          case 4:
            if (!(arrayOfPromises.length === 1)) {
              _context2.next = 6;
              break;
            }

            return _context2.abrupt('return', arrayOfPromises[0]);

          case 6:
            resolve = void 0;
            reject = void 0;
            result = new _promise2.default(function (x, y) {
              resolve = x;
              reject = y;
            });
            rejects = [];


            arrayOfPromises.forEach(function () {
              var _ref2 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(prom) {
                var x;
                return _regenerator2.default.wrap(function _callee$(_context) {
                  while (1) {
                    switch (_context.prev = _context.next) {
                      case 0:
                        _context.prev = 0;
                        _context.next = 3;
                        return prom;

                      case 3:
                        x = _context.sent;

                        resolve(x);
                        _context.next = 11;
                        break;

                      case 7:
                        _context.prev = 7;
                        _context.t0 = _context['catch'](0);

                        rejects = [].concat((0, _toConsumableArray3.default)(rejects), [_context.t0]);

                        if (rejects.length === arrayOfPromises.length) {
                          reject(rejects);
                        }

                      case 11:
                      case 'end':
                        return _context.stop();
                    }
                  }
                }, _callee, this, [[0, 7]]);
              }));

              function firstOrAllErrors(_x2) {
                return _ref2.apply(this, arguments);
              }

              return firstOrAllErrors;
            }());

            return _context2.abrupt('return', result);

          case 12:
          case 'end':
            return _context2.stop();
        }
      }
    }, _callee2, this);
  }));

  return function anyPromise(_x) {
    return _ref.apply(this, arguments);
  };
}();

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