redux-boost/es/state/utils/saga.js

Redux-Boost

import _regeneratorRuntime from 'babel-runtime/regenerator';
import _extends from 'babel-runtime/helpers/extends';
import { createActions } from 'redux-yo';
import { takeLatest, take, fork, cancel } from 'redux-saga/effects';

export function createSaga(name, saga) {
  var actions = createActions(['sagaStart', 'sagaSuccess', 'sagaFail'], name);

  return _extends({
    name: name,
    action: actions.sagaStart,

    saga: saga,
    listener: takeLatest(actions.sagaStart, saga)
  }, actions);
}

export function dedupeEvery(pattern, saga) {
  var inProgress = {};

  return fork( /*#__PURE__*/_regeneratorRuntime.mark(function dedupe() {
    var _this = this;

    var _loop;

    return _regeneratorRuntime.wrap(function dedupe$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            _loop = /*#__PURE__*/_regeneratorRuntime.mark(function _loop() {
              var action, _action$payload, name, deduplicate, task;

              return _regeneratorRuntime.wrap(function _loop$(_context) {
                while (1) {
                  switch (_context.prev = _context.next) {
                    case 0:
                      _context.next = 2;
                      return take(pattern);

                    case 2:
                      action = _context.sent;
                      _action$payload = action.payload, name = _action$payload.name, deduplicate = _action$payload.deduplicate;

                      if (!(inProgress[name] && deduplicate)) {
                        _context.next = 7;
                        break;
                      }

                      _context.next = 7;
                      return cancel(inProgress[name]);

                    case 7:
                      _context.next = 9;
                      return fork(saga, action);

                    case 9:
                      task = _context.sent;


                      inProgress[name] = task;

                      task.done.then(function () {
                        return delete inProgress[name];
                      }).catch(function () {
                        return delete inProgress[name];
                      });

                    case 12:
                    case 'end':
                      return _context.stop();
                  }
                }
              }, _loop, _this);
            });

          case 1:
            if (!true) {
              _context2.next = 5;
              break;
            }

            return _context2.delegateYield(_loop(), 't0', 3);

          case 3:
            _context2.next = 1;
            break;

          case 5:
          case 'end':
            return _context2.stop();
        }
      }
    }, dedupe, this);
  }));
}