@tacky/store/lib/decorators/effect.js

State management framework based on react

"use strict";

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

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

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

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

var _config = require("../const/config");

var _store = require("../core/store");

var _symbol = require("../const/symbol");

var _common = require("../utils/common");

var _interfaces = require("../interfaces");

var _error = require("../utils/error");

var _decorator = require("../utils/decorator");

var _domain = require("../core/domain");

var _collector = require("../core/collector");

/**
 * @todo: enhance effect feature, such as takeLead, takeLast
 */
function createEffect(target, name, original) {
  var stringMethodName = (0, _common.convert2UniqueString)(name);
  return /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
    var _len,
        payload,
        _key,
        length,
        _args = arguments;

    return _regenerator["default"].wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            this[_symbol.CURRENT_MATERIAL_TYPE] = _interfaces.EMaterialType.EFFECT;

            _domain.materialCallStack.push(this[_symbol.CURRENT_MATERIAL_TYPE]);

            for (_len = _args.length, payload = new Array(_len), _key = 0; _key < _len; _key++) {
              payload[_key] = _args[_key];
            }

            _context.next = 5;
            return _store.store.dispatch({
              name: stringMethodName,
              payload: payload,
              type: _interfaces.EMaterialType.EFFECT,
              domain: this,
              original: (0, _common.bind)(original, this)
            });

          case 5:
            _domain.materialCallStack.pop();

            length = _domain.materialCallStack.length;
            this[_symbol.CURRENT_MATERIAL_TYPE] = _domain.materialCallStack[length - 1] || _interfaces.EMaterialType.DEFAULT;

            if (_config.ctx.timeTravel.isActive && !(0, _common.includes)(_domain.materialCallStack, _interfaces.EMaterialType.EFFECT)) {
              _collector.historyCollector.save();

              _collector.historyCollector.endBatch();
            }

          case 9:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, this);
  }));
}
/**
 * decorator @effect, handle some async process and effect.
 */


function effect() {
  var decorator = function decorator(target, name, descriptor) {
    (0, _error.invariant)(_config.ctx.middleware.effect, 'If you want to use @effect decorator, please turn on the built-in effect middleware. By \"config(...)\".'); // typescript only: @effect method = async () => {}

    if (descriptor === void 0) {
      var effectFunc;
      Object.defineProperty(target, name, {
        enumerable: true,
        configurable: true,
        get: function get() {
          return effectFunc;
        },
        set: function set(original) {
          effectFunc = createEffect(target, name, original);
        }
      });
      return;
    } // babel/typescript: @effect method() {}


    if (descriptor.value !== void 0) {
      var original = descriptor.value;
      descriptor.value = createEffect(target, name, original);
      return descriptor;
    } // babel only: @effect method = () => {}


    var initializer = descriptor.initializer;

    descriptor.initializer = function () {
      (0, _error.invariant)(!!initializer, 'The initializer of the descriptor doesn\'t exist, please compile it by using babel and correspond decorator plugin.');
      return createEffect(target, name, initializer && initializer.call(this));
    };

    return descriptor;
  };

  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
    args[_key2] = arguments[_key2];
  }

  if ((0, _decorator.quacksLikeADecorator)(args)) {
    // @effect
    return decorator.apply(null, args);
  } // @effect(args)


  return decorator;
}