genji-core/lib/getAction.js

The core lightweight library for genji, based on redux and redux-saga.

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

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

var _getIterator2 = _interopRequireDefault(require("@babel/runtime/core-js/get-iterator"));

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

var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));

var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));

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

var _invariant = _interopRequireDefault(require("invariant"));

var _prefixedDispatch = _interopRequireDefault(require("./prefixedDispatch"));

var _utils = require("./utils");

function getAction(effects, model, onError, onEffect) {
  var actions = {};

  for (var key in effects) {
    if (Object.prototype.hasOwnProperty.call(effects, key)) {
      actions[key] = getSingleAction(key, effects[key], model, onError, onEffect);
    }
  }

  return actions;
}

function getSingleAction(key, effect, model, onError, onEffect) {
  (0, _invariant.default)((0, _utils.isFunction)(effect), '[model.action]: action should be function');

  var actionWithCatch =
  /*#__PURE__*/
  function () {
    var _ref2 = (0, _asyncToGenerator2.default)(
    /*#__PURE__*/
    _regenerator.default.mark(function _callee(action, _ref) {
      var dispatch,
          rest,
          _args = arguments;
      return _regenerator.default.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              dispatch = _ref.dispatch, rest = (0, _objectWithoutProperties2.default)(_ref, ["dispatch"]);
              _context.prev = 1;
              dispatch = (0, _prefixedDispatch.default)(dispatch, model);
              _context.next = 5;
              return effect(action, (0, _objectSpread2.default)({
                dispatch: dispatch
              }, rest));

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

            case 8:
              _context.prev = 8;
              _context.t0 = _context["catch"](1);
              onError(_context.t0, {
                key: key,
                actionArgs: _args
              });

              if (_context.t0._dontReject) {
                _context.next = 13;
                break;
              }

              throw _context.t0;

            case 13:
            case "end":
              return _context.stop();
          }
        }
      }, _callee, this, [[1, 8]]);
    }));

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

  var actionWithOnEffect = applyOnEffect(onEffect, actionWithCatch, model, key);
  return actionWithOnEffect;
}

function applyOnEffect(fns, effect, model, key) {
  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;

  try {
    for (var _iterator = (0, _getIterator2.default)(fns), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var fn = _step.value;
      effect = fn(effect, model, key);
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return != null) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }

  return effect;
}