redux-logic
Version:
Redux middleware for organizing all your business logic. Intercept actions and perform async processing.
170 lines (165 loc) • 7.41 kB
JavaScript
;
require("core-js/modules/es.symbol.js");
require("core-js/modules/es.symbol.description.js");
require("core-js/modules/es.symbol.iterator.js");
require("core-js/modules/es.error.cause.js");
require("core-js/modules/es.array.from.js");
require("core-js/modules/es.array.iterator.js");
require("core-js/modules/es.array.slice.js");
require("core-js/modules/es.regexp.to-string.js");
require("core-js/modules/es.string.iterator.js");
require("core-js/modules/web.dom-collections.iterator.js");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = logicWrapper;
require("core-js/modules/es.array.concat.js");
require("core-js/modules/es.array.filter.js");
require("core-js/modules/es.function.name.js");
require("core-js/modules/es.object.to-string.js");
require("core-js/modules/es.regexp.exec.js");
require("core-js/modules/es.regexp.test.js");
require("core-js/modules/esnext.iterator.constructor.js");
require("core-js/modules/esnext.iterator.filter.js");
require("core-js/modules/esnext.iterator.some.js");
var _rxjs = require("rxjs");
var _operators = require("rxjs/operators");
var _createLogicAction$ = _interopRequireDefault(require("./createLogicAction$"));
var _utils = require("./utils");
var _createDispatch2 = _interopRequireDefault(require("./createDispatch"));
var _execProcessFn = _interopRequireDefault(require("./execProcessFn"));
var _createCancelled$2 = _interopRequireDefault(require("./createCancelled$"));
var _createDepObject = _interopRequireDefault(require("./createDepObject"));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
var MATCH_ALL_TYPES = '*';
function logicWrapper(logic, store, deps, monitor$) {
var name = logic.name,
type = logic.type,
cancelType = logic.cancelType,
latest = logic.latest,
debounce = logic.debounce,
throttle = logic.throttle,
processFn = logic.process,
dispatchReturn = logic.processOptions.dispatchReturn;
var getState = store.getState;
// cancel on cancelType or if take latest specified
var cancelTypes = [].concat(type && latest ? type : []).concat(cancelType || []);
return function wrappedLogic(actionIn$) {
// we want to share the same copy amongst all here
var action$ = actionIn$.pipe((0, _operators.share)());
var cancel$ = cancelTypes.length ? action$.pipe((0, _operators.filter)(function (action) {
return matchesType(cancelTypes, action.type);
})) : null;
var hasIntercept = logic.validate || logic.transform;
// shortcut optimization if no intercept let action fall through
// and just exec the processFn
var mergeMapOrTap = hasIntercept ? (0, _operators.mergeMap)(function (action) {
return (0, _createLogicAction$.default)({
action: action,
logic: logic,
store: store,
deps: deps,
cancel$: cancel$,
monitor$: monitor$,
action$: action$
});
}) : (0, _operators.tap)(function (action) {
// mimic the events as if went through createLogicAction$
// also in createLogicAction$
monitor$.next({
action: action,
name: name,
op: 'begin'
});
monitor$.next({
action: action,
nextAction: action,
name: name,
shouldProcess: true,
op: 'next'
});
var _createCancelled$ = (0, _createCancelled$2.default)({
action: action,
cancel$: cancel$,
monitor$: monitor$,
logic: logic
}),
cancelled$ = _createCancelled$.cancelled$,
setInterceptComplete = _createCancelled$.setInterceptComplete;
var _createDispatch = (0, _createDispatch2.default)({
action: action,
cancel$: cancel$,
cancelled$: cancelled$,
logic: logic,
monitor$: monitor$,
store: store
}),
dispatch = _createDispatch.dispatch,
dispatch$ = _createDispatch.dispatch$,
done = _createDispatch.done;
var ctx = {}; // no intercept, so empty ctx;
var depObj = (0, _createDepObject.default)({
deps: deps,
cancelled$: cancelled$,
ctx: ctx,
getState: getState,
action: action,
action$: action$
});
_rxjs.asapScheduler.schedule(function () {
setInterceptComplete();
(0, _execProcessFn.default)({
depObj: depObj,
dispatch: dispatch,
dispatch$: dispatch$,
dispatchReturn: dispatchReturn,
done: done,
name: name,
processFn: processFn
});
});
});
var matchingOps = [
// operations to perform, falsey filtered out
(0, _operators.filter)(function (action) {
return matchesType(type, action.type);
}), debounce ? (0, _operators.debounceTime)(debounce) : null, throttle ? (0, _operators.throttleTime)(throttle) : null, mergeMapOrTap].filter(_utils.identityFn);
var matchingAction$ = action$.pipe.apply(action$, _toConsumableArray(matchingOps));
// shortcut optimization
// if type is match all '*', then no need to create other side of pipe
if (type === MATCH_ALL_TYPES) {
return matchingAction$;
}
// types that don't match will bypass this logic
var nonMatchingAction$ = action$.pipe((0, _operators.filter)(function (action) {
return !matchesType(type, action.type);
}));
return (0, _rxjs.merge)(nonMatchingAction$, matchingAction$);
};
}
function matchesType(tStrArrRe, type) {
/* istanbul ignore if */
if (!tStrArrRe) {
return false;
} // nothing matches none
if (_typeof(tStrArrRe) === 'symbol') {
return tStrArrRe === type;
}
if (typeof tStrArrRe === 'string') {
return tStrArrRe === type || tStrArrRe === MATCH_ALL_TYPES;
}
if (Array.isArray(tStrArrRe)) {
return tStrArrRe.some(function (x) {
return matchesType(x, type);
});
}
// else assume it is a RegExp
return tStrArrRe.test(type);
}