esnext-async/lib/main.js

Patterns for asynchronous computation in ES.next

"use strict";

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

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

var _regenerator2 = _interopRequireDefault(_regenerator);

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

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

/* eslint-disable consistent-return, lines-around-comment */
var run = exports.run = function () {
  var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(fn) {
    var _len,
        args,
        _key,
        _args = arguments;

    return _regenerator2.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.prev = 0;

            for (_len = _args.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
              args[_key - 1] = _args[_key];
            }

            _context.next = 4;
            return fn.apply(undefined, args);

          case 4:
            return _context.abrupt("return", _context.sent);

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

            setTimeout(function () {
              throw _context.t0;
            }, 0);

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

  return function run(_x, _x2) {
    return _ref.apply(this, arguments);
  };
}();
/* eslint-enable consistent-return, lines-around-comment */

var loop = exports.loop = function () {
  var _ref2 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee3(fn) {
    var _this = this;

    return _regenerator2.default.wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            _context3.next = 2;
            return run((0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2() {
              return _regenerator2.default.wrap(function _callee2$(_context2) {
                while (1) {
                  switch (_context2.prev = _context2.next) {
                    case 0:
                      if (!true) {
                        _context2.next = 5;
                        break;
                      }

                      _context2.next = 3;
                      return fn();

                    case 3:
                      _context2.next = 0;
                      break;

                    case 5:
                    case "end":
                      return _context2.stop();
                  }
                }
              }, _callee2, _this);
            })));

          case 2:
          case "end":
            return _context3.stop();
        }
      }
    }, _callee3, this);
  }));

  return function loop(_x3) {
    return _ref2.apply(this, arguments);
  };
}();

exports.tryCatch = tryCatch;

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

function tryCatch(fn) {
  var _this2 = this;

  return function () {
    var _ref4 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee4() {
      for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        args[_key2] = arguments[_key2];
      }

      return _regenerator2.default.wrap(function _callee4$(_context4) {
        while (1) {
          switch (_context4.prev = _context4.next) {
            case 0:
              _context4.next = 2;
              return run.apply(undefined, [fn].concat(args));

            case 2:
              return _context4.abrupt("return", _context4.sent);

            case 3:
            case "end":
              return _context4.stop();
          }
        }
      }, _callee4, _this2);
    }));

    return function (_x4) {
      return _ref4.apply(this, arguments);
    };
  }();
}