@vve/redux-saga 8.4.0 → 9.0.0-alpha.10

package/es/internal/proc.js

@@ -1,54 +1,33 @@
-function _defineEnumerableProperties(obj, descs) { for (var key in descs) { var desc = descs[key]; desc.configurable = desc.enumerable = true; if ("value" in desc) desc.writable = true; Object.defineProperty(obj, key, desc); } if (Object.getOwnPropertySymbols) { var objectSymbols = Object.getOwnPropertySymbols(descs); for (var i = 0; i < objectSymbols.length; i++) { var sym = objectSymbols[i]; var desc = descs[sym]; desc.configurable = desc.enumerable = true; if ("value" in desc) desc.writable = true; Object.defineProperty(obj, sym, desc); } } return obj; }
-
-function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
-
-import { noop, kTrue, is, log as _log, check, deferred, uid as nextEffectId, array, remove, object, TASK, CANCEL, SELF_CANCELLATION, makeIterator, createSetContextWarning, deprecate, updateIncentive } from './utils';
-import { asap, suspend, flush } from './scheduler';
-import { asEffect } from './io';
-import { stdChannel as _stdChannel, eventChannel, isEnd } from './channel';
-import { buffers } from './buffers';
-import { pageKey, reducerKey } from '../utils';
-import completeIOType from './convenient-io';
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import { noop, kTrue, is, log as _log, check, deferred, uid as nextEffectId, array, remove, object, TASK, CANCEL, SELF_CANCELLATION, makeIterator, createSetContextWarning, deprecate, updateIncentive } from "./utils";
+import { asap, suspend, flush } from "./scheduler";
+import { asEffect } from "./io";
+import { stdChannel as _stdChannel, eventChannel, isEnd } from "./channel";
+import { buffers } from "./buffers";
+import { pageKey, reducerKey } from "../utils";
+import completeIOType from "./convenient-io";
 export var NOT_ITERATOR_ERROR = 'proc first argument (Saga function result) must be an iterator';
 export var CHANNEL_END = {
-  toString: function toString() {
+  toString() {
     return '@@redux-saga/CHANNEL_END';
   }
 };
 export var TASK_CANCEL = {
-  toString: function toString() {
+  toString() {
     return '@@redux-saga/TASK_CANCEL';
   }
 };
 var matchers = {
-  wildcard: function wildcard() {
-    return kTrue;
-  },
-  "default": function _default(pattern) {
-    return typeof pattern === 'symbol' ? function (input) {
-      return input.type === pattern;
-    } : function (input) {
-      return input.type === String(pattern);
-    };
-  },
-  array: function array(patterns) {
-    return function (input) {
-      return patterns.some(function (p) {
-        return matcher(p)(input);
-      });
-    };
-  },
-  predicate: function predicate(_predicate) {
-    return function (input) {
-      return _predicate(input);
-    };
-  }
+  wildcard: () => kTrue,
+  default: pattern => typeof pattern === 'symbol' ? input => input.type === pattern : input => input.type === String(pattern),
+  array: patterns => input => patterns.some(p => matcher(p)(input)),
+  predicate: _predicate => input => _predicate(input)
 };
-
 function matcher(pattern) {
   // prettier-ignore
-  return (pattern === '*' ? matchers.wildcard : is.array(pattern) ? matchers.array : is.stringableFunc(pattern) ? matchers["default"] : is.func(pattern) ? matchers.predicate : matchers["default"])(pattern);
+  return (pattern === '*' ? matchers.wildcard : is.array(pattern) ? matchers.array : is.stringableFunc(pattern) ? matchers.default : is.func(pattern) ? matchers.predicate : matchers.default)(pattern);
 }
+
 /**
   Used to track a parent task and its forks
   In the new fork model, forked tasks are attached by default to their parent
@@ -64,100 +43,81 @@ function matcher(pattern) {
   - It aborts if any uncaught error bubbles up from forks
   - If it completes, the return value is the one returned by the main task
 **/
-
-
 function forkQueue(name, mainTask, cb) {
   var tasks = [],
-      result,
-      completed = false;
+    result,
+    completed = false;
   addTask(mainTask);
-
   function abort(err) {
     cancelAll();
     cb(err, true);
   }
-
   function addTask(task) {
     tasks.push(task);
-
-    task.cont = function (res, isErr) {
+    task.cont = (res, isErr) => {
       if (completed) {
         return;
       }
-
       remove(tasks, task);
       task.cont = noop;
-
       if (isErr) {
         abort(res);
       } else {
         if (task === mainTask) {
           result = res;
         }
-
         if (!tasks.length) {
           completed = true;
           cb(result);
         }
       }
-    }; // task.cont.cancel = task.cancel
-
+    };
+    // task.cont.cancel = task.cancel
   }
 
   function cancelAll() {
     if (completed) {
       return;
     }
-
     completed = true;
-    tasks.forEach(function (t) {
+    tasks.forEach(t => {
       t.cont = noop;
       t.cancel();
     });
     tasks = [];
   }
-
   return {
-    addTask: addTask,
-    cancelAll: cancelAll,
-    abort: abort,
-    getTasks: function getTasks() {
-      return tasks;
-    },
-    taskNames: function taskNames() {
-      return tasks.map(function (t) {
-        return t.name;
-      });
-    }
+    addTask,
+    cancelAll,
+    abort,
+    getTasks: () => tasks,
+    taskNames: () => tasks.map(t => t.name)
   };
 }
-
 function createTaskIterator(_ref) {
   var context = _ref.context,
-      fn = _ref.fn,
-      args = _ref.args;
-
+    fn = _ref.fn,
+    args = _ref.args;
   if (is.iterator(fn)) {
     return fn;
-  } // catch synchronous failures; see #152 and #441
-
+  }
 
+  // catch synchronous failures; see #152 and #441
   var result, error;
-
   try {
     result = fn.apply(context, args);
   } catch (err) {
     error = err;
-  } // i.e. a generator function returns an iterator
-
+  }
 
+  // i.e. a generator function returns an iterator
   if (is.iterator(result)) {
     return result;
-  } // do not bubble up synchronous failures for detached forks
-  // instead create a failed task. See #152 and #441
-
+  }
 
-  return error ? makeIterator(function () {
+  // do not bubble up synchronous failures for detached forks
+  // instead create a failed task. See #152 and #441
+  return error ? makeIterator(() => {
     throw error;
   }) : makeIterator(function () {
     var pc;
@@ -165,15 +125,11 @@ function createTaskIterator(_ref) {
       done: false,
       value: result
     };
-
-    var ret = function ret(value) {
-      return {
-        done: true,
-        value: value
-      };
-    };
-
-    return function (arg) {
+    var ret = value => ({
+      done: true,
+      value
+    });
+    return arg => {
       if (!pc) {
         pc = true;
         return eff;
@@ -183,95 +139,63 @@ function createTaskIterator(_ref) {
     };
   }());
 }
-
-var wrapHelper = function wrapHelper(helper) {
-  return {
-    fn: helper
-  };
-};
-
-export default function proc(iterator, subscribe, dispatch, getState, parentContext, options, parentEffectId, name, cont) {
-  if (subscribe === void 0) {
-    subscribe = function subscribe() {
-      return noop;
-    };
-  }
-
-  if (dispatch === void 0) {
-    dispatch = noop;
-  }
-
-  if (getState === void 0) {
-    getState = noop;
-  }
-
-  if (parentContext === void 0) {
-    parentContext = {};
-  }
-
-  if (options === void 0) {
-    options = {};
-  }
-
-  if (parentEffectId === void 0) {
-    parentEffectId = 0;
-  }
-
-  if (name === void 0) {
-    name = 'anonymous';
-  }
-
+var wrapHelper = helper => ({
+  fn: helper
+});
+export default function proc(iterator) {
+  var subscribe = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : () => noop;
+  var dispatch = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : noop;
+  var getState = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : noop;
+  var parentContext = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  var options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+  var parentEffectId = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 0;
+  var name = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : 'anonymous';
+  var cont = arguments.length > 8 ? arguments[8] : undefined;
   check(iterator, is.iterator, NOT_ITERATOR_ERROR);
   var effectsString = '[...effects]';
-  var runParallelEffect = deprecate(runAllEffect, updateIncentive(effectsString, "all(" + effectsString + ")"));
-  var _options = options,
-      sagaMonitor = _options.sagaMonitor,
-      logger = _options.logger,
-      onError = _options.onError;
+  var runParallelEffect = deprecate(runAllEffect, updateIncentive(effectsString, `all(${effectsString})`));
+  var sagaMonitor = options.sagaMonitor,
+    logger = options.logger,
+    onError = options.onError;
   var log = logger || _log;
-
-  var logError = function logError(err) {
+  var logError = err => {
     var message = err.sagaStack;
-
     if (!message && err.stack) {
-      message = err.stack.split('\n')[0].indexOf(err.message) !== -1 ? err.stack : "Error: " + err.message + "\n" + err.stack;
+      message = err.stack.split('\n')[0].indexOf(err.message) !== -1 ? err.stack : `Error: ${err.message}\n${err.stack}`;
     }
-
-    log('error', "uncaught at " + name, message || err.message || err);
+    log('error', `uncaught at ${name}`, message || err.message || err);
   };
-
   var stdChannel = _stdChannel(subscribe);
-
   var taskContext = Object.create(parentContext);
   /**
     Tracks the current effect cancellation
     Each time the generator progresses. calling runEffect will set a new value
     on it. It allows propagating cancellation to child effects
   **/
-
   next.cancel = noop;
+
   /**
     Creates a new task descriptor for this generator, We'll also create a main task
     to track the main flow (besides other forked tasks)
   **/
-
   var task = newTask(parentEffectId, name, iterator, cont);
   var mainTask = {
-    name: name,
+    name,
     cancel: cancelMain,
     isRunning: true
   };
   var taskQueue = forkQueue(name, mainTask, end);
+
   /**
     cancellation of the main task. We'll simply resume the Generator with a Cancel
   **/
-
   function cancelMain() {
     if (mainTask.isRunning && !mainTask.isCancelled) {
       mainTask.isCancelled = true;
       next(TASK_CANCEL);
     }
   }
+
   /**
     This may be called by a parent generator to trigger/propagate cancellation
     cancel all pending tasks (including the main task), then end the current task.
@@ -279,8 +203,6 @@ export default function proc(iterator, subscribe, dispatch, getState, parentCont
     It's also propagated to all joiners of this task and their execution tree/joiners
      Cancellation is noop for terminated/Cancelled tasks tasks
   **/
-
-
   function cancel() {
     /**
       We need to check both Running and Cancelled status
@@ -292,7 +214,6 @@ export default function proc(iterator, subscribe, dispatch, getState, parentCont
       /**
         Ending with a Never result will propagate the Cancellation to all joiners
       **/
-
       end(TASK_CANCEL);
     }
   }
@@ -300,32 +221,31 @@ export default function proc(iterator, subscribe, dispatch, getState, parentCont
     attaches cancellation logic to this task's continuation
     this will permit cancellation to propagate down the call chain
   **/
+  cont && (cont.cancel = cancel);
 
+  // tracks the running status
+  iterator._isRunning = true;
 
-  cont && (cont.cancel = cancel); // tracks the running status
-
-  iterator._isRunning = true; // kicks up the generator
-
-  next(); // then return the task descriptor to the caller
+  // kicks up the generator
+  next();
 
+  // then return the task descriptor to the caller
   return task;
+
   /**
     This is the generator driver
     It's a recursive async/continuation function which calls itself
     until the generator terminates or throws
   **/
-
   function next(arg, isErr) {
     // Preventive measure. If we end up here, then there is really something wrong
     if (!mainTask.isRunning) {
       throw new Error('Trying to resume an already finished generator');
     }
-
     try {
       var result;
-
       if (isErr) {
-        result = iterator["throw"](arg);
+        result = iterator.throw(arg);
       } else if (arg === TASK_CANCEL) {
         /**
           getting TASK_CANCEL automatically cancels the main task
@@ -337,26 +257,23 @@ export default function proc(iterator, subscribe, dispatch, getState, parentCont
         /**
           Cancels the current effect; this will propagate the cancellation down to any called tasks
         **/
-
         next.cancel();
         /**
           If this Generator has a `return` method then invokes it
           This will jump to the finally block
         **/
-
-        result = is.func(iterator["return"]) ? iterator["return"](TASK_CANCEL) : {
+        result = is.func(iterator.return) ? iterator.return(TASK_CANCEL) : {
           done: true,
           value: TASK_CANCEL
         };
       } else if (arg === CHANNEL_END) {
         // We get CHANNEL_END by taking from a channel that ended using `take` (and not `takem` used to trap End of channels)
-        result = is.func(iterator["return"]) ? iterator["return"]() : {
+        result = is.func(iterator.return) ? iterator.return() : {
           done: true
         };
       } else {
         result = iterator.next(arg);
       }
-
       if (!result.done) {
         runEffect(result.value, parentEffectId, '', next);
       } else {
@@ -370,27 +287,23 @@ export default function proc(iterator, subscribe, dispatch, getState, parentCont
       if (mainTask.isCancelled) {
         logError(error);
       }
-
       mainTask.isMainRunning = false;
       mainTask.cont(error, true);
     }
   }
-
   function end(result, isErr) {
     iterator._isRunning = false;
     stdChannel.close();
-
     if (!isErr) {
       iterator._result = result;
       iterator._deferredEnd && iterator._deferredEnd.resolve(result);
     } else {
       if (result instanceof Error) {
         Object.defineProperty(result, 'sagaStack', {
-          value: "at " + name + " \n " + (result.sagaStack || result.stack),
+          value: `at ${name} \n ${result.sagaStack || result.stack}`,
           configurable: true
         });
       }
-
       if (!task.cont) {
         if (result instanceof Error && onError) {
           onError(result);
@@ -398,84 +311,72 @@ export default function proc(iterator, subscribe, dispatch, getState, parentCont
           logError(result);
         }
       }
-
       iterator._error = result;
       iterator._isAborted = true;
       iterator._deferredEnd && iterator._deferredEnd.reject(result);
     }
-
     task.cont && task.cont(result, isErr);
-    task.joiners.forEach(function (j) {
-      return j.cb(result, isErr);
-    });
+    task.joiners.forEach(j => j.cb(result, isErr));
     task.joiners = null;
   }
-
-  function runEffect(effect, parentEffectId, label, cb) {
-    if (label === void 0) {
-      label = '';
-    }
-
+  function runEffect(effect, parentEffectId) {
+    var label = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+    var cb = arguments.length > 3 ? arguments[3] : undefined;
     if (getContext('mobxStyle')) {
       effect = completeIOType(effect);
     }
-
     var effectId = nextEffectId();
     sagaMonitor && sagaMonitor.effectTriggered({
-      effectId: effectId,
-      parentEffectId: parentEffectId,
-      label: label,
-      effect: effect
+      effectId,
+      parentEffectId,
+      label,
+      effect
     });
+
     /**
       completion callback and cancel callback are mutually exclusive
       We can't cancel an already completed effect
       And We can't complete an already cancelled effectId
     **/
+    var effectSettled;
 
-    var effectSettled; // Completion callback passed to the appropriate effect runner
-
+    // Completion callback passed to the appropriate effect runner
     function currCb(res, isErr) {
       if (effectSettled) {
         return;
       }
-
       effectSettled = true;
       cb.cancel = noop; // defensive measure
-
       if (sagaMonitor) {
         isErr ? sagaMonitor.effectRejected(effectId, res) : sagaMonitor.effectResolved(effectId, res);
       }
-
       cb(res, isErr);
-    } // tracks down the current cancel
-
-
-    currCb.cancel = noop; // setup cancellation logic on the parent cb
+    }
+    // tracks down the current cancel
+    currCb.cancel = noop;
 
-    cb.cancel = function () {
+    // setup cancellation logic on the parent cb
+    cb.cancel = () => {
       // prevents cancelling an already completed effect
       if (effectSettled) {
         return;
       }
-
       effectSettled = true;
       /**
         propagates cancel downward
         catch uncaught cancellations errors; since we can no longer call the completion
         callback, log errors raised during cancellations into the console
       **/
-
       try {
         currCb.cancel();
       } catch (err) {
         logError(err);
       }
-
       currCb.cancel = noop; // defensive measure
 
       sagaMonitor && sagaMonitor.effectCancelled(effectId);
     };
+
     /**
       each effect runner must attach its own logic of cancellation to the provided callback
       it allows this generator to propagate cancellation downward.
@@ -488,72 +389,55 @@ export default function proc(iterator, subscribe, dispatch, getState, parentCont
       promise[CANCEL] method in their returned promises
       ATTENTION! calling cancel must have no effect on an already completed or cancelled effect
     **/
-
-
-    var data; // prettier-ignore
-
-    return (// Non declarative effect
-      is.promise(effect) ? resolvePromise(effect, currCb) : is.helper(effect) ? runForkEffect(wrapHelper(effect), effectId, currCb) : is.iterator(effect) ? resolveIterator(effect, effectId, name, currCb) // declarative effects
-      : is.array(effect) ? runParallelEffect(effect, effectId, currCb) : (data = asEffect.take(effect)) ? runTakeEffect(data, currCb) : (data = asEffect.put(effect)) ? runPutEffect(data, currCb) : (data = asEffect.all(effect)) ? runAllEffect(data, effectId, currCb) : (data = asEffect.race(effect)) ? runRaceEffect(data, effectId, currCb) : (data = asEffect.call(effect)) ? runCallEffect(data, effectId, currCb) : (data = asEffect.cps(effect)) ? runCPSEffect(data, currCb) : (data = asEffect.fork(effect)) ? runForkEffect(data, effectId, currCb) : (data = asEffect.join(effect)) ? runJoinEffect(data, currCb) : (data = asEffect.cancel(effect)) ? runCancelEffect(data, currCb) : (data = asEffect.select(effect)) ? runSelectEffect(data, currCb) : (data = asEffect.selectSelf(effect)) ? runSelectSelfEffect(data, currCb) : (data = asEffect.putMutation(effect)) ? runPutMutationEffect(data, currCb) : (data = asEffect.putAsyncAction(effect)) ? runPutAsyncEffect(data, currCb) : (data = asEffect.actionChannel(effect)) ? runChannelEffect(data, currCb) : (data = asEffect.flush(effect)) ? runFlushEffect(data, currCb) : (data = asEffect.cancelled(effect)) ? runCancelledEffect(data, currCb) : (data = asEffect.getContext(effect)) ? runGetContextEffect(data, currCb) : (data = asEffect.setContext(effect)) ? runSetContextEffect(data, currCb) :
-      /* anything else returned as is */
-      currCb(effect)
+    var data;
+    // prettier-ignore
+    return (
+      // Non declarative effect
+      is.promise(effect) ? resolvePromise(effect, currCb) : is.helper(effect) ? runForkEffect(wrapHelper(effect), effectId, currCb) : is.iterator(effect) ? resolveIterator(effect, effectId, name, currCb)
+
+      // declarative effects
+      : is.array(effect) ? runParallelEffect(effect, effectId, currCb) : (data = asEffect.take(effect)) ? runTakeEffect(data, currCb) : (data = asEffect.put(effect)) ? runPutEffect(data, currCb) : (data = asEffect.all(effect)) ? runAllEffect(data, effectId, currCb) : (data = asEffect.race(effect)) ? runRaceEffect(data, effectId, currCb) : (data = asEffect.call(effect)) ? runCallEffect(data, effectId, currCb) : (data = asEffect.cps(effect)) ? runCPSEffect(data, currCb) : (data = asEffect.fork(effect)) ? runForkEffect(data, effectId, currCb) : (data = asEffect.join(effect)) ? runJoinEffect(data, currCb) : (data = asEffect.cancel(effect)) ? runCancelEffect(data, currCb) : (data = asEffect.select(effect)) ? runSelectEffect(data, currCb) : (data = asEffect.selectSelf(effect)) ? runSelectSelfEffect(data, currCb) : (data = asEffect.putMutation(effect)) ? runPutMutationEffect(data, currCb) : (data = asEffect.putAsyncAction(effect)) ? runPutAsyncEffect(data, currCb) : (data = asEffect.actionChannel(effect)) ? runChannelEffect(data, currCb) : (data = asEffect.flush(effect)) ? runFlushEffect(data, currCb) : (data = asEffect.cancelled(effect)) ? runCancelledEffect(data, currCb) : (data = asEffect.getContext(effect)) ? runGetContextEffect(data, currCb) : (data = asEffect.setContext(effect)) ? runSetContextEffect(data, currCb) : /* anything else returned as is */currCb(effect)
     );
   }
-
   function resolvePromise(promise, cb) {
     var cancelPromise = promise[CANCEL];
-
     if (is.func(cancelPromise)) {
       cb.cancel = cancelPromise;
     } else if (is.func(promise.abort)) {
-      cb.cancel = function () {
-        return promise.abort();
-      }; // TODO: add support for the fetch API, whenever they get around to
+      cb.cancel = () => promise.abort();
+      // TODO: add support for the fetch API, whenever they get around to
       // adding cancel support
-
     }
 
-    promise.then(cb, function (error) {
-      return cb(error, true);
-    });
+    promise.then(cb, error => cb(error, true));
   }
-
   function resolveIterator(iterator, effectId, name, cb) {
     proc(iterator, subscribe, dispatch, getState, taskContext, options, effectId, name, cb);
   }
-
   function runTakeEffect(_ref2, cb) {
     var channel = _ref2.channel,
-        pattern = _ref2.pattern,
-        maybe = _ref2.maybe;
+      pattern = _ref2.pattern,
+      maybe = _ref2.maybe;
     channel = channel || stdChannel;
-
-    var takeCb = function takeCb(inp) {
-      return inp instanceof Error ? cb(inp, true) : isEnd(inp) && !maybe ? cb(CHANNEL_END) : cb(inp);
-    };
-
+    var takeCb = inp => inp instanceof Error ? cb(inp, true) : isEnd(inp) && !maybe ? cb(CHANNEL_END) : cb(inp);
     try {
       channel.take(takeCb, namespaceFilter(pattern, matcher));
     } catch (err) {
       return cb(err, true);
     }
-
     cb.cancel = takeCb.cancel;
   }
-
   function runPutEffect(_ref3, cb) {
     var channel = _ref3.channel,
-        action = _ref3.action,
-        resolve = _ref3.resolve;
-
+      action = _ref3.action,
+      resolve = _ref3.resolve;
     /**
       Schedule the put in case another saga is holding a lock.
       The put will be executed atomically. ie nested puts will execute after
       this put has terminated.
     **/
-    asap(function () {
+    asap(() => {
       var result;
-
       try {
         result = (channel ? channel.put : dispatch)(namespaceDecorate(action));
       } catch (error) {
@@ -561,71 +445,59 @@ export default function proc(iterator, subscribe, dispatch, getState, parentCont
         if (channel || resolve) return cb(error, true);
         logError(error);
       }
-
       if (resolve && is.promise(result)) {
         resolvePromise(result, cb);
       } else {
         return cb(result);
       }
-    }); // Put effects are non cancellables
+    });
+    // Put effects are non cancellables
   }
 
   function runCallEffect(_ref4, effectId, cb) {
     var context = _ref4.context,
-        fn = _ref4.fn,
-        args = _ref4.args;
-    var result; // catch synchronous failures; see #152
-
+      fn = _ref4.fn,
+      args = _ref4.args;
+    var result;
+    // catch synchronous failures; see #152
     try {
       result = fn.apply(context, args);
     } catch (error) {
       return cb(error, true);
     }
-
     return is.promise(result) ? resolvePromise(result, cb) : is.iterator(result) ? resolveIterator(result, effectId, fn.name, cb) : cb(result);
   }
-
   function runCPSEffect(_ref5, cb) {
     var context = _ref5.context,
-        fn = _ref5.fn,
-        args = _ref5.args;
-
+      fn = _ref5.fn,
+      args = _ref5.args;
     // CPS (ie node style functions) can define their own cancellation logic
     // by setting cancel field on the cb
+
     // catch synchronous failures; see #152
     try {
-      var cpsCb = function cpsCb(err, res) {
-        return is.undef(err) ? cb(res) : cb(err, true);
-      };
-
+      var cpsCb = (err, res) => is.undef(err) ? cb(res) : cb(err, true);
       fn.apply(context, args.concat(cpsCb));
-
       if (cpsCb.cancel) {
-        cb.cancel = function () {
-          return cpsCb.cancel();
-        };
+        cb.cancel = () => cpsCb.cancel();
       }
     } catch (error) {
       return cb(error, true);
     }
   }
-
   function runForkEffect(_ref6, effectId, cb) {
     var context = _ref6.context,
-        fn = _ref6.fn,
-        args = _ref6.args,
-        detached = _ref6.detached;
+      fn = _ref6.fn,
+      args = _ref6.args,
+      detached = _ref6.detached;
     var taskIterator = createTaskIterator({
-      context: context,
-      fn: fn,
-      args: args
+      context,
+      fn,
+      args
     });
-
     try {
       suspend();
-
       var _task = proc(taskIterator, subscribe, dispatch, getState, taskContext, options, effectId, fn.name, detached ? null : noop);
-
       if (detached) {
         cb(_task);
       } else {
@@ -640,66 +512,55 @@ export default function proc(iterator, subscribe, dispatch, getState, parentCont
       }
     } finally {
       flush();
-    } // Fork effects are non cancellables
-
+    }
+    // Fork effects are non cancellables
   }
 
   function runJoinEffect(t, cb) {
     if (t.isRunning()) {
       var joiner = {
-        task: task,
-        cb: cb
-      };
-
-      cb.cancel = function () {
-        return remove(t.joiners, joiner);
+        task,
+        cb
       };
-
+      cb.cancel = () => remove(t.joiners, joiner);
       t.joiners.push(joiner);
     } else {
       t.isAborted() ? cb(t.error(), true) : cb(t.result());
     }
   }
-
   function runCancelEffect(taskToCancel, cb) {
     if (taskToCancel === SELF_CANCELLATION) {
       taskToCancel = task;
     }
-
     if (taskToCancel.isRunning()) {
       taskToCancel.cancel();
     }
-
-    cb(); // cancel effects are non cancellables
+    cb();
+    // cancel effects are non cancellables
   }
 
   function runAllEffect(effects, effectId, cb) {
     var keys = Object.keys(effects);
-
     if (!keys.length) {
       return cb(is.array(effects) ? [] : {});
     }
-
     var completedCount = 0;
     var completed;
     var results = {};
     var childCbs = {};
-
     function checkEffectEnd() {
       if (completedCount === keys.length) {
         completed = true;
-        cb(is.array(effects) ? array.from(_extends({}, results, {
+        cb(is.array(effects) ? array.from(_objectSpread(_objectSpread({}, results), {}, {
           length: keys.length
         })) : results);
       }
     }
-
-    keys.forEach(function (key) {
-      var chCbAtKey = function chCbAtKey(res, isErr) {
+    keys.forEach(key => {
+      var chCbAtKey = (res, isErr) => {
         if (completed) {
           return;
         }
-
         if (isErr || isEnd(res) || res === CHANNEL_END || res === TASK_CANCEL) {
           cb.cancel();
           cb(res, isErr);
@@ -709,89 +570,70 @@ export default function proc(iterator, subscribe, dispatch, getState, parentCont
           checkEffectEnd();
         }
       };
-
       chCbAtKey.cancel = noop;
       childCbs[key] = chCbAtKey;
     });
-
-    cb.cancel = function () {
+    cb.cancel = () => {
       if (!completed) {
         completed = true;
-        keys.forEach(function (key) {
-          return childCbs[key].cancel();
-        });
+        keys.forEach(key => childCbs[key].cancel());
       }
     };
-
-    keys.forEach(function (key) {
-      return runEffect(effects[key], effectId, key, childCbs[key]);
-    });
+    keys.forEach(key => runEffect(effects[key], effectId, key, childCbs[key]));
   }
-
   function runRaceEffect(effects, effectId, cb) {
     var completed;
     var keys = Object.keys(effects);
     var childCbs = {};
-    keys.forEach(function (key) {
-      var chCbAtKey = function chCbAtKey(res, isErr) {
+    keys.forEach(key => {
+      var chCbAtKey = (res, isErr) => {
         if (completed) {
           return;
         }
-
         if (isErr) {
           // Race Auto cancellation
           cb.cancel();
           cb(res, true);
         } else if (!isEnd(res) && res !== CHANNEL_END && res !== TASK_CANCEL) {
-          var _response;
-
           cb.cancel();
           completed = true;
-          var response = (_response = {}, _response[key] = res, _response);
-          cb(is.array(effects) ? [].slice.call(_extends({}, response, {
+          var response = {
+            [key]: res
+          };
+          cb(is.array(effects) ? [].slice.call(_objectSpread(_objectSpread({}, response), {}, {
             length: keys.length
           })) : response);
         }
       };
-
       chCbAtKey.cancel = noop;
       childCbs[key] = chCbAtKey;
     });
-
-    cb.cancel = function () {
+    cb.cancel = () => {
       // prevents unnecessary cancellation
       if (!completed) {
         completed = true;
-        keys.forEach(function (key) {
-          return childCbs[key].cancel();
-        });
+        keys.forEach(key => childCbs[key].cancel());
       }
     };
-
-    keys.forEach(function (key) {
+    keys.forEach(key => {
       if (completed) {
         return;
       }
-
       runEffect(effects[key], effectId, key, childCbs[key]);
     });
   }
-
   function runSelectEffect(_ref7, cb) {
     var selector = _ref7.selector,
-        args = _ref7.args;
-
+      args = _ref7.args;
     try {
       // compat
-      var state = _extends({}, getState());
-
+      var state = _objectSpread({}, getState());
       state[getContext(pageKey)] = state[getReducerKey()];
-      cb(selector.apply(void 0, [state].concat(args)));
+      cb(selector(state, ...args));
     } catch (error) {
       cb(error, true);
     }
   }
-
   function runSelectSelfEffect(_, cb) {
     try {
       var state = getState()[getReducerKey()];
@@ -800,19 +642,17 @@ export default function proc(iterator, subscribe, dispatch, getState, parentCont
       cb(error, true);
     }
   }
-
   function runPutMutationEffect(_ref8, cb) {
     var fn = _ref8.fn;
     var action = {
       type: '@@INNER/SAGA_EDIT',
       page: getReducerKey(),
-      fn: fn
+      fn
     };
     return runPutEffect({
-      action: action
+      action
     }, cb);
   }
-
   function runPutAsyncEffect(_ref9, cb) {
     var action = _ref9.action;
     return runPutEffect({
@@ -821,44 +661,35 @@ export default function proc(iterator, subscribe, dispatch, getState, parentCont
       if (err) {
         return cb(res, err);
       }
-
       resolvePromise(action['@@INNER/DONE_MARK'], cb);
     });
   }
-
   function runChannelEffect(_ref10, cb) {
     var pattern = _ref10.pattern,
-        buffer = _ref10.buffer;
+      buffer = _ref10.buffer;
     var match = matcher(pattern);
     match.pattern = pattern;
     cb(eventChannel(subscribe, buffer || buffers.fixed(), match));
   }
-
   function runCancelledEffect(data, cb) {
     cb(!!mainTask.isCancelled);
   }
-
   function runFlushEffect(channel, cb) {
     channel.flush(cb);
   }
-
   function runGetContextEffect(prop, cb) {
     cb(prop === ' ' ? taskContext : taskContext[prop]);
   }
-
   function runSetContextEffect(props, cb) {
     object.assign(taskContext, props);
     cb();
   }
-
   function getContext(prop) {
     return taskContext[prop];
   }
-
   function getReducerKey() {
     return getContext(reducerKey) || getContext(pageKey);
   }
-
   function namespaceDecorate(action) {
     if (getContext(pageKey)) {
       Object.defineProperty(action, pageKey, {
@@ -868,48 +699,47 @@ export default function proc(iterator, subscribe, dispatch, getState, parentCont
         writable: false
       });
     }
-
     return action;
-  } // todo remove
-
+  }
 
+  // todo remove
   function namespaceFilter(pattern, next) {
     var nxt = next(pattern);
-    return function (action) {
+    return action => {
       return nxt(action);
     };
   }
-
   function newTask(id, name, iterator, cont) {
-    var _done, _ref11, _mutatorMap;
-
     iterator._deferredEnd = null;
-    return _ref11 = {}, _ref11[TASK] = true, _ref11.id = id, _ref11.name = name, _done = "done", _mutatorMap = {}, _mutatorMap[_done] = _mutatorMap[_done] || {}, _mutatorMap[_done].get = function () {
-      if (iterator._deferredEnd) {
-        return iterator._deferredEnd.promise;
-      } else {
-        var def = deferred();
-        iterator._deferredEnd = def;
-
-        if (!iterator._isRunning) {
-          iterator._error ? def.reject(iterator._error) : def.resolve(iterator._result);
+    return {
+      [TASK]: true,
+      id,
+      name,
+      get done() {
+        if (iterator._deferredEnd) {
+          return iterator._deferredEnd.promise;
+        } else {
+          var def = deferred();
+          iterator._deferredEnd = def;
+          if (!iterator._isRunning) {
+            iterator._error ? def.reject(iterator._error) : def.resolve(iterator._result);
+          }
+          return def.promise;
         }
-
-        return def.promise;
+      },
+      cont,
+      joiners: [],
+      cancel,
+      isRunning: () => iterator._isRunning,
+      isCancelled: () => iterator._isCancelled,
+      isAborted: () => iterator._isAborted,
+      result: () => iterator._result,
+      error: () => iterator._error,
+      setContext(props) {
+        check(props, is.object, createSetContextWarning('task', props));
+        object.assign(taskContext, props);
       }
-    }, _ref11.cont = cont, _ref11.joiners = [], _ref11.cancel = cancel, _ref11.isRunning = function isRunning() {
-      return iterator._isRunning;
-    }, _ref11.isCancelled = function isCancelled() {
-      return iterator._isCancelled;
-    }, _ref11.isAborted = function isAborted() {
-      return iterator._isAborted;
-    }, _ref11.result = function result() {
-      return iterator._result;
-    }, _ref11.error = function error() {
-      return iterator._error;
-    }, _ref11.setContext = function setContext(props) {
-      check(props, is.object, createSetContextWarning('task', props));
-      object.assign(taskContext, props);
-    }, _defineEnumerableProperties(_ref11, _mutatorMap), _ref11;
-  }
-}
+    };
+  }
+}
+//# sourceMappingURL=proc.js.map