diff --git a/.babelrc b/.babelrc index c208a1e..a19f608 100644 --- a/.babelrc +++ b/.babelrc @@ -1,8 +1,14 @@ { - "presets": ["es2015", "react"], - "env": { - "development": { - "presets": [] + "presets": [ + "es2015", + "react" + ], + "plugins": [ + "transform-runtime" + ], + "env": { + "development": { + "presets": [] + } } - } } diff --git a/dist/ReactProxy.js b/dist/ReactProxy.js index 0231783..3fa6939 100644 --- a/dist/ReactProxy.js +++ b/dist/ReactProxy.js @@ -52,7 +52,7 @@ return /******/ (function(modules) { // webpackBootstrap /************************************************************************/ /******/ ([ /* 0 */ -/***/ function(module, exports, __webpack_require__) { +/***/ (function(module, exports, __webpack_require__) { 'use strict'; @@ -61,23 +61,38 @@ return /******/ (function(modules) { // webpackBootstrap }); exports.newKey = exports.VALUE = exports.CHILD_MOVED = exports.CHILD_CHANGED = exports.CHILD_REMOVED = exports.CHILD_ADDED = undefined; - var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); + var _getIterator2 = __webpack_require__(15); + + var _getIterator3 = _interopRequireDefault(_getIterator2); + + var _slicedToArray2 = __webpack_require__(32); + + var _slicedToArray3 = _interopRequireDefault(_slicedToArray2); + + var _regenerator = __webpack_require__(33); + + var _regenerator2 = _interopRequireDefault(_regenerator); + + var _defineProperty2 = __webpack_require__(31); + + var _defineProperty3 = _interopRequireDefault(_defineProperty2); exports.get = get; exports.getAll = getAll; exports.create = create; exports.update = update; + exports.updateAll = updateAll; exports.push = push; exports.remove = remove; exports.sync = sync; - var _reduxSaga = __webpack_require__(9); + var _reduxSaga = __webpack_require__(!(function webpackMissingModule() { var e = new Error("Cannot find module \"redux-saga\""); e.code = 'MODULE_NOT_FOUND'; throw e; }())); - var _effects = __webpack_require__(8); + var _effects = __webpack_require__(!(function webpackMissingModule() { var e = new Error("Cannot find module \"redux-saga/effects\""); e.code = 'MODULE_NOT_FOUND'; throw e; }())); - var _marked = [get, getAll, create, update, push, remove, runSync, sync].map(regeneratorRuntime.mark); + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + var _marked = [get, getAll, create, update, updateAll, push, remove, runSync, sync].map(_regenerator2.default.mark); var CHILD_ADDED = exports.CHILD_ADDED = 'child_added'; var CHILD_REMOVED = exports.CHILD_REMOVED = 'child_removed'; @@ -88,12 +103,12 @@ return /******/ (function(modules) { // webpackBootstrap var EVENT_TYPES = [CHILD_ADDED, CHILD_REMOVED, CHILD_CHANGED, CHILD_MOVED, VALUE]; var newOpts = function newOpts() { - var name = arguments.length <= 0 || arguments[0] === undefined ? 'data' : arguments[0]; + var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'data'; var opts = {}; var chan = (0, _reduxSaga.eventChannel)(function (emit) { opts.handler = function (obj) { - emit(_defineProperty({}, name, obj)); + emit((0, _defineProperty3.default)({}, name, obj)); }; return function () {}; }); @@ -118,7 +133,7 @@ return /******/ (function(modules) { // webpackBootstrap */ function get(path, key) { var ref, data; - return regeneratorRuntime.wrap(function get$(_context) { + return _regenerator2.default.wrap(function get$(_context) { while (1) { switch (_context.prev = _context.next) { case 0: @@ -150,7 +165,7 @@ return /******/ (function(modules) { // webpackBootstrap */ function getAll(path) { var ref, data; - return regeneratorRuntime.wrap(function getAll$(_context2) { + return _regenerator2.default.wrap(function getAll$(_context2) { while (1) { switch (_context2.prev = _context2.next) { case 0: @@ -190,7 +205,7 @@ return /******/ (function(modules) { // webpackBootstrap function create(path, fn) { var key, payload, opts, ref, _ref, _ref2, _, error; - return regeneratorRuntime.wrap(function create$(_context3) { + return _regenerator2.default.wrap(function create$(_context3) { while (1) { switch (_context3.prev = _context3.next) { case 0: @@ -211,7 +226,7 @@ return /******/ (function(modules) { // webpackBootstrap case 10: _ref = _context3.sent; - _ref2 = _slicedToArray(_ref, 2); + _ref2 = (0, _slicedToArray3.default)(_ref, 2); _ = _ref2[0]; error = _ref2[1].error; return _context3.abrupt('return', error); @@ -238,7 +253,7 @@ return /******/ (function(modules) { // webpackBootstrap function update(path, key, payload) { var opts, ref, _ref3, _ref4, _, error; - return regeneratorRuntime.wrap(function update$(_context4) { + return _regenerator2.default.wrap(function update$(_context4) { while (1) { switch (_context4.prev = _context4.next) { case 0: @@ -261,7 +276,7 @@ return /******/ (function(modules) { // webpackBootstrap case 8: _ref3 = _context4.sent; - _ref4 = _slicedToArray(_ref3, 2); + _ref4 = (0, _slicedToArray3.default)(_ref3, 2); _ = _ref4[0]; error = _ref4[1].error; return _context4.abrupt('return', error); @@ -274,6 +289,62 @@ return /******/ (function(modules) { // webpackBootstrap }, _marked[3], this); } + /** + * Updates existing data in the database with `update()` + * + * @param path + * @param key + * @param payload + * @returns {*} + * * import { updateAll } from 'firebase-saga'; + * + * const postDate = { title: 'My Second Post', + * body: 'Second post details', + * timestamp: +new Date }; + * const updates = {}; + * updates['/posts/' + newPostKey] = postData; + * updates['/user-posts/' + uid + '/' + newPostKey] = postData; + * yield call(updateAll, 'posts', updates); + */ + function updateAll(path, payload) { + var opts, ref, _ref5, _ref6, _, error; + + return _regenerator2.default.wrap(function updateAll$(_context5) { + while (1) { + switch (_context5.prev = _context5.next) { + case 0: + if (!(typeof payload === 'function')) { + _context5.next = 4; + break; + } + + _context5.next = 3; + return (0, _effects.call)(payload); + + case 3: + payload = _context5.sent; + + case 4: + opts = newOpts('error'); + ref = firebase.database().ref(path); + _context5.next = 8; + return [(0, _effects.call)([ref, ref.update], payload, opts.handler), (0, _effects.take)(opts)]; + + case 8: + _ref5 = _context5.sent; + _ref6 = (0, _slicedToArray3.default)(_ref5, 2); + _ = _ref6[0]; + error = _ref6[1].error; + return _context5.abrupt('return', error); + + case 13: + case 'end': + return _context5.stop(); + } + } + }, _marked[4], this); + } + /** * Generates a new child location using a unique key * @@ -291,51 +362,51 @@ return /******/ (function(modules) { // webpackBootstrap *); */ function push(path, fn) { - var getKey = arguments.length <= 2 || arguments[2] === undefined ? false : arguments[2]; + var getKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - var key, payload, opts, ref, _ref5, _ref6, _, error; + var key, payload, opts, ref, _ref7, _ref8, _, error; - return regeneratorRuntime.wrap(function push$(_context5) { + return _regenerator2.default.wrap(function push$(_context6) { while (1) { - switch (_context5.prev = _context5.next) { + switch (_context6.prev = _context6.next) { case 0: - _context5.next = 2; + _context6.next = 2; return (0, _effects.call)(newKey, path); case 2: - key = _context5.sent; - _context5.next = 5; + key = _context6.sent; + _context6.next = 5; return (0, _effects.call)(fn, key); case 5: - payload = _context5.sent; + payload = _context6.sent; opts = newOpts('error'); ref = firebase.database().ref(path); - _context5.next = 10; + _context6.next = 10; return [(0, _effects.call)([ref, ref.push], payload, opts.handler), (0, _effects.take)(opts)]; case 10: - _ref5 = _context5.sent; - _ref6 = _slicedToArray(_ref5, 2); - _ = _ref6[0]; - error = _ref6[1].error; + _ref7 = _context6.sent; + _ref8 = (0, _slicedToArray3.default)(_ref7, 2); + _ = _ref8[0]; + error = _ref8[1].error; if (!(getKey && error === undefined)) { - _context5.next = 16; + _context6.next = 16; break; } - return _context5.abrupt('return', key); + return _context6.abrupt('return', key); case 16: - return _context5.abrupt('return', error); + return _context6.abrupt('return', error); case 17: case 'end': - return _context5.stop(); + return _context6.stop(); } } - }, _marked[4], this); + }, _marked[5], this); } /** @@ -366,68 +437,68 @@ return /******/ (function(modules) { // webpackBootstrap * yield call(remove, 'posts', '1234') */ function remove(path, key) { - var opts, ref, _ref7, _ref8, _, error; + var opts, ref, _ref9, _ref10, _, error; - return regeneratorRuntime.wrap(function remove$(_context6) { + return _regenerator2.default.wrap(function remove$(_context7) { while (1) { - switch (_context6.prev = _context6.next) { + switch (_context7.prev = _context7.next) { case 0: opts = newOpts('error'); ref = firebase.database().ref(path + '/' + key); - _context6.next = 4; + _context7.next = 4; return [(0, _effects.call)([ref, ref.remove], opts.handler), (0, _effects.take)(opts)]; case 4: - _ref7 = _context6.sent; - _ref8 = _slicedToArray(_ref7, 2); - _ = _ref8[0]; - error = _ref8[1].error; - return _context6.abrupt('return', error); + _ref9 = _context7.sent; + _ref10 = (0, _slicedToArray3.default)(_ref9, 2); + _ = _ref10[0]; + error = _ref10[1].error; + return _context7.abrupt('return', error); case 9: case 'end': - return _context6.stop(); + return _context7.stop(); } } - }, _marked[5], this); + }, _marked[6], this); } function runSync(ref, eventType, actionCreator) { - var opts, _ref9, data; + var opts, _ref11, data; - return regeneratorRuntime.wrap(function runSync$(_context7) { + return _regenerator2.default.wrap(function runSync$(_context8) { while (1) { - switch (_context7.prev = _context7.next) { + switch (_context8.prev = _context8.next) { case 0: opts = newOpts(); - _context7.next = 3; + _context8.next = 3; return (0, _effects.call)([ref, ref.on], eventType, opts.handler); case 3: if (false) { - _context7.next = 12; + _context8.next = 12; break; } - _context7.next = 6; + _context8.next = 6; return (0, _effects.take)(opts); case 6: - _ref9 = _context7.sent; - data = _ref9.data; - _context7.next = 10; + _ref11 = _context8.sent; + data = _ref11.data; + _context8.next = 10; return (0, _effects.put)(actionCreator({ key: data.key, value: data.val() })); case 10: - _context7.next = 3; + _context8.next = 3; break; case 12: case 'end': - return _context7.stop(); + return _context8.stop(); } } - }, _marked[6], this); + }, _marked[7], this); } /** @@ -447,25 +518,25 @@ return /******/ (function(modules) { // webpackBootstrap *} */ function sync(path) { - var mapEventToAction = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; + var mapEventToAction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; var limit = arguments[2]; var ref, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, type, action; - return regeneratorRuntime.wrap(function sync$(_context8) { + return _regenerator2.default.wrap(function sync$(_context9) { while (1) { - switch (_context8.prev = _context8.next) { + switch (_context9.prev = _context9.next) { case 0: ref = typeof limit === 'number' ? firebase.database().ref(path).limitToLast(limit) : firebase.database().ref(path); _iteratorNormalCompletion = true; _didIteratorError = false; _iteratorError = undefined; - _context8.prev = 4; - _iterator = EVENT_TYPES[Symbol.iterator](); + _context9.prev = 4; + _iterator = (0, _getIterator3.default)(EVENT_TYPES); case 6: if (_iteratorNormalCompletion = (_step = _iterator.next()).done) { - _context8.next = 15; + _context9.next = 15; break; } @@ -473,2199 +544,1829 @@ return /******/ (function(modules) { // webpackBootstrap action = mapEventToAction[type]; if (!(typeof action === 'function')) { - _context8.next = 12; + _context9.next = 12; break; } - _context8.next = 12; + _context9.next = 12; return (0, _effects.fork)(runSync, ref, type, action); case 12: _iteratorNormalCompletion = true; - _context8.next = 6; + _context9.next = 6; break; case 15: - _context8.next = 21; + _context9.next = 21; break; case 17: - _context8.prev = 17; - _context8.t0 = _context8['catch'](4); + _context9.prev = 17; + _context9.t0 = _context9['catch'](4); _didIteratorError = true; - _iteratorError = _context8.t0; + _iteratorError = _context9.t0; case 21: - _context8.prev = 21; - _context8.prev = 22; + _context9.prev = 21; + _context9.prev = 22; if (!_iteratorNormalCompletion && _iterator.return) { _iterator.return(); } case 24: - _context8.prev = 24; + _context9.prev = 24; if (!_didIteratorError) { - _context8.next = 27; + _context9.next = 27; break; } throw _iteratorError; case 27: - return _context8.finish(24); + return _context9.finish(24); case 28: - return _context8.finish(21); + return _context9.finish(21); case 29: case 'end': - return _context8.stop(); + return _context9.stop(); } } - }, _marked[7], this, [[4, 17, 21, 29], [22,, 24, 28]]); + }, _marked[8], this, [[4, 17, 21, 29], [22,, 24, 28]]); } -/***/ }, +/***/ }), /* 1 */ -/***/ function(module, exports) { +/***/ (function(module, exports, __webpack_require__) { - 'use strict'; + var store = __webpack_require__(25)('wks') + , uid = __webpack_require__(26) + , Symbol = __webpack_require__(2).Symbol + , USE_SYMBOL = typeof Symbol == 'function'; - Object.defineProperty(exports, "__esModule", { - value: true - }); + var $exports = module.exports = function(name){ + return store[name] || (store[name] = + USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name)); + }; - var _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; }; + $exports.store = store; - var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; }; +/***/ }), +/* 2 */ +/***/ (function(module, exports) { - exports.check = check; - exports.remove = remove; - exports.deferred = deferred; - exports.arrayOfDeffered = arrayOfDeffered; - exports.delay = delay; - exports.createMockTask = createMockTask; - exports.autoInc = autoInc; - exports.makeIterator = makeIterator; - exports.log = log; - - function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } - - var sym = exports.sym = function sym(id) { - return '@@redux-saga/' + id; - }; - var TASK = exports.TASK = sym('TASK'); - var MATCH = exports.MATCH = sym('MATCH'); - var CANCEL = exports.CANCEL = sym('cancelPromise'); - var konst = exports.konst = function konst(v) { - return function () { - return v; - }; - }; - var kTrue = exports.kTrue = konst(true); - var kFalse = exports.kFalse = konst(false); - var noop = exports.noop = function noop() {}; - var ident = exports.ident = function ident(v) { - return v; - }; + // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 + var global = module.exports = typeof window != 'undefined' && window.Math == Math + ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')(); + if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef - function check(value, predicate, error) { - if (!predicate(value)) { - log('error', 'uncaught at check', error); - throw new Error(error); - } - } +/***/ }), +/* 3 */ +/***/ (function(module, exports) { - var is = exports.is = { - undef: function undef(v) { - return v === null || v === undefined; - }, - notUndef: function notUndef(v) { - return v !== null && v !== undefined; - }, - func: function func(f) { - return typeof f === 'function'; - }, - number: function number(n) { - return typeof n === 'number'; - }, - array: Array.isArray, - promise: function promise(p) { - return p && is.func(p.then); - }, - iterator: function iterator(it) { - return it && is.func(it.next) && is.func(it.throw); - }, - task: function task(t) { - return t && t[TASK]; - }, - take: function take(ch) { - return ch && is.func(ch.take); - }, - put: function put(ch) { - return ch && is.func(ch.put); - }, - observable: function observable(ob) { - return ob && is.func(ob.subscribe); - }, - buffer: function buffer(buf) { - return buf && is.func(buf.isEmpty) && is.func(buf.take) && is.func(buf.put); - }, - pattern: function pattern(pat) { - return pat && (typeof pat === 'string' || (typeof pat === 'undefined' ? 'undefined' : _typeof(pat)) === 'symbol' || is.func(pat) || is.array(pat)); - } - }; + var core = module.exports = {version: '2.4.0'}; + if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef - function remove(array, item) { - var index = array.indexOf(item); - if (index >= 0) { - array.splice(index, 1); - } - } +/***/ }), +/* 4 */ +/***/ (function(module, exports, __webpack_require__) { - function deferred() { - var props = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; + // Thank's IE8 for his funny defineProperty + module.exports = !__webpack_require__(21)(function(){ + return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7; + }); - var def = _extends({}, props); - var promise = new Promise(function (resolve, reject) { - def.resolve = resolve; - def.reject = reject; - }); - def.promise = promise; - return def; - } +/***/ }), +/* 5 */ +/***/ (function(module, exports, __webpack_require__) { + + var dP = __webpack_require__(9) + , createDesc = __webpack_require__(23); + module.exports = __webpack_require__(4) ? function(object, key, value){ + return dP.f(object, key, createDesc(1, value)); + } : function(object, key, value){ + object[key] = value; + return object; + }; - function arrayOfDeffered(length) { - var arr = []; - for (var i = 0; i < length; i++) { - arr.push(deferred()); - } - return arr; - } +/***/ }), +/* 6 */ +/***/ (function(module, exports) { - function delay(ms) { - var val = arguments.length <= 1 || arguments[1] === undefined ? true : arguments[1]; + module.exports = {}; - var timeoutId = void 0; - var promise = new Promise(function (resolve) { - timeoutId = setTimeout(function () { - return resolve(val); - }, ms); - }); +/***/ }), +/* 7 */ +/***/ (function(module, exports, __webpack_require__) { - promise[CANCEL] = function () { - return clearTimeout(timeoutId); - }; + var isObject = __webpack_require__(11); + module.exports = function(it){ + if(!isObject(it))throw TypeError(it + ' is not an object!'); + return it; + }; - return promise; - } +/***/ }), +/* 8 */ +/***/ (function(module, exports) { - function createMockTask() { - var _ref; - - var running = true; - var _result = void 0, - _error = void 0; - - return _ref = {}, _defineProperty(_ref, TASK, true), _defineProperty(_ref, 'isRunning', function isRunning() { - return running; - }), _defineProperty(_ref, 'result', function result() { - return _result; - }), _defineProperty(_ref, 'error', function error() { - return _error; - }), _defineProperty(_ref, 'setRunning', function setRunning(b) { - return running = b; - }), _defineProperty(_ref, 'setResult', function setResult(r) { - return _result = r; - }), _defineProperty(_ref, 'setError', function setError(e) { - return _error = e; - }), _ref; - } + var hasOwnProperty = {}.hasOwnProperty; + module.exports = function(it, key){ + return hasOwnProperty.call(it, key); + }; - function autoInc() { - var seed = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0]; +/***/ }), +/* 9 */ +/***/ (function(module, exports, __webpack_require__) { + + var anObject = __webpack_require__(7) + , IE8_DOM_DEFINE = __webpack_require__(42) + , toPrimitive = __webpack_require__(57) + , dP = Object.defineProperty; + + exports.f = __webpack_require__(4) ? Object.defineProperty : function defineProperty(O, P, Attributes){ + anObject(O); + P = toPrimitive(P, true); + anObject(Attributes); + if(IE8_DOM_DEFINE)try { + return dP(O, P, Attributes); + } catch(e){ /* empty */ } + if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!'); + if('value' in Attributes)O[P] = Attributes.value; + return O; + }; - return function () { - return ++seed; - }; - } +/***/ }), +/* 10 */ +/***/ (function(module, exports) { - var kThrow = function kThrow(err) { - throw err; - }; - var kReturn = function kReturn(value) { - return { value: value, done: true }; + // 7.2.1 RequireObjectCoercible(argument) + module.exports = function(it){ + if(it == undefined)throw TypeError("Can't call method on " + it); + return it; }; - function makeIterator(next) { - var thro = arguments.length <= 1 || arguments[1] === undefined ? kThrow : arguments[1]; - var name = arguments.length <= 2 || arguments[2] === undefined ? '' : arguments[2]; - - var iterator = { name: name, next: next, throw: thro, return: kReturn }; - if (typeof Symbol !== 'undefined') { - iterator[Symbol.iterator] = function () { - return iterator; - }; - } - return iterator; - } - /** - Print error in a useful way whether in a browser environment - (with expandable error stack traces), or in a node.js environment - (text-only log output) - **/ - function log(level, message, error) { - /*eslint-disable no-console*/ - if (typeof window === 'undefined') { - console.log('redux-saga ' + level + ': ' + message + '\n' + (error && error.stack || error)); - } else { - console[level].call(console, message, error); - } - } +/***/ }), +/* 11 */ +/***/ (function(module, exports) { - var internalErr = exports.internalErr = function internalErr(err) { - return new Error('\n redux-saga: Error checking hooks detected an inconsisten state. This is likely a bug\n in redux-saga code and not yours. Thanks for reporting this in the project\'s github repo.\n Error: ' + err + '\n'); + module.exports = function(it){ + return typeof it === 'object' ? it !== null : typeof it === 'function'; }; -/***/ }, -/* 2 */ -/***/ function(module, exports, __webpack_require__) { +/***/ }), +/* 12 */ +/***/ (function(module, exports, __webpack_require__) { - /* WEBPACK VAR INJECTION */(function(process) {'use strict'; + var shared = __webpack_require__(25)('keys') + , uid = __webpack_require__(26); + module.exports = function(key){ + return shared[key] || (shared[key] = uid(key)); + }; - Object.defineProperty(exports, "__esModule", { - value: true - }); - exports.UNDEFINED_INPUT_ERROR = exports.INVALID_BUFFER = exports.isEnd = exports.END = undefined; - exports.emitter = emitter; - exports.channel = channel; - exports.eventChannel = eventChannel; +/***/ }), +/* 13 */ +/***/ (function(module, exports) { - var _utils = __webpack_require__(1); + // 7.1.4 ToInteger + var ceil = Math.ceil + , floor = Math.floor; + module.exports = function(it){ + return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it); + }; - var _buffers = __webpack_require__(4); +/***/ }), +/* 14 */ +/***/ (function(module, exports, __webpack_require__) { - var CHANNEL_END_TYPE = '@@redux-saga/CHANNEL_END'; - var END = exports.END = { type: CHANNEL_END_TYPE }; - var isEnd = exports.isEnd = function isEnd(a) { - return a && a.type === CHANNEL_END_TYPE; + // to indexed object, toObject with fallback for non-array-like ES3 strings + var IObject = __webpack_require__(43) + , defined = __webpack_require__(10); + module.exports = function(it){ + return IObject(defined(it)); }; - function emitter() { - var subscribers = []; +/***/ }), +/* 15 */ +/***/ (function(module, exports, __webpack_require__) { - function subscribe(sub) { - subscribers.push(sub); - return function () { - return (0, _utils.remove)(subscribers, sub); - }; - } + module.exports = { "default": __webpack_require__(34), __esModule: true }; - function emit(item) { - var arr = subscribers.slice(); - for (var i = 0, len = arr.length; i < len; i++) { - arr[i](item); - } - } +/***/ }), +/* 16 */ +/***/ (function(module, exports, __webpack_require__) { - return { - subscribe: subscribe, - emit: emit - }; - } + // getting tag from 19.1.3.6 Object.prototype.toString() + var cof = __webpack_require__(17) + , TAG = __webpack_require__(1)('toStringTag') + // ES3 wrong here + , ARG = cof(function(){ return arguments; }()) == 'Arguments'; - var INVALID_BUFFER = exports.INVALID_BUFFER = 'invalid buffer passed to channel factory function'; - var UNDEFINED_INPUT_ERROR = exports.UNDEFINED_INPUT_ERROR = 'Saga was provided with an undefined action'; + // fallback for IE11 Script Access Denied error + var tryGet = function(it, key){ + try { + return it[key]; + } catch(e){ /* empty */ } + }; - if (process.env.NODE_ENV !== 'production') { - exports.UNDEFINED_INPUT_ERROR = UNDEFINED_INPUT_ERROR += '\nHints:\n - check that your Action Creator returns a non-undefined value\n - if the Saga was started using runSaga, check that your subscribe source provides the action to its listeners\n '; - } + module.exports = function(it){ + var O, T, B; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T + // builtinTag case + : ARG ? cof(O) + // ES3 arguments fallback + : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B; + }; - function channel(buffer) { - var closed = false; - var takers = []; +/***/ }), +/* 17 */ +/***/ (function(module, exports) { - if (arguments.length > 0) { - (0, _utils.check)(buffer, _utils.is.buffer, INVALID_BUFFER); - } else { - buffer = _buffers.buffers.fixed(); - } + var toString = {}.toString; - function checkForbiddenStates() { - if (closed && takers.length) { - throw (0, _utils.internalErr)('Cannot have a closed channel with pending takers'); - } - if (takers.length && !buffer.isEmpty()) { - throw (0, _utils.internalErr)('Cannot have pending takers with non empty buffer'); - } - } + module.exports = function(it){ + return toString.call(it).slice(8, -1); + }; - function put(input) { - checkForbiddenStates(); - (0, _utils.check)(input, _utils.is.notUndef, UNDEFINED_INPUT_ERROR); - if (!closed) { - if (takers.length) { - for (var i = 0; i < takers.length; i++) { - var cb = takers[i]; - if (!cb[_utils.MATCH] || cb[_utils.MATCH](input)) { - takers.splice(i, 1); - return cb(input); - } - } - } else { - buffer.put(input); - } - } - } +/***/ }), +/* 18 */ +/***/ (function(module, exports, __webpack_require__) { - function take(cb, matcher) { - checkForbiddenStates(); - (0, _utils.check)(cb, _utils.is.func, 'channel.take\'s callback must be a function'); - if (arguments.length > 1) { - (0, _utils.check)(matcher, _utils.is.func, 'channel.take\'s matcher argument must be a function'); - cb[_utils.MATCH] = matcher; - } - if (closed && buffer.isEmpty()) { - cb(END); - } else if (!buffer.isEmpty()) { - cb(buffer.take()); - } else { - takers.push(cb); - cb.cancel = function () { - return (0, _utils.remove)(takers, cb); + var isObject = __webpack_require__(11) + , document = __webpack_require__(2).document + // in old IE typeof document.createElement is 'object' + , is = isObject(document) && isObject(document.createElement); + module.exports = function(it){ + return is ? document.createElement(it) : {}; + }; + +/***/ }), +/* 19 */ +/***/ (function(module, exports) { + + // IE 8- don't enum bug keys + module.exports = ( + 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf' + ).split(','); + +/***/ }), +/* 20 */ +/***/ (function(module, exports, __webpack_require__) { + + var global = __webpack_require__(2) + , core = __webpack_require__(3) + , ctx = __webpack_require__(40) + , hide = __webpack_require__(5) + , PROTOTYPE = 'prototype'; + + var $export = function(type, name, source){ + var IS_FORCED = type & $export.F + , IS_GLOBAL = type & $export.G + , IS_STATIC = type & $export.S + , IS_PROTO = type & $export.P + , IS_BIND = type & $export.B + , IS_WRAP = type & $export.W + , exports = IS_GLOBAL ? core : core[name] || (core[name] = {}) + , expProto = exports[PROTOTYPE] + , target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE] + , key, own, out; + if(IS_GLOBAL)source = name; + for(key in source){ + // contains in native + own = !IS_FORCED && target && target[key] !== undefined; + if(own && key in exports)continue; + // export native or passed + out = own ? target[key] : source[key]; + // prevent global pollution for namespaces + exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key] + // bind timers to global for call from export context + : IS_BIND && own ? ctx(out, global) + // wrap global constructors for prevent change them in library + : IS_WRAP && target[key] == out ? (function(C){ + var F = function(a, b, c){ + if(this instanceof C){ + switch(arguments.length){ + case 0: return new C; + case 1: return new C(a); + case 2: return new C(a, b); + } return new C(a, b, c); + } return C.apply(this, arguments); }; + F[PROTOTYPE] = C[PROTOTYPE]; + return F; + // make static versions for prototype methods + })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out; + // export proto methods to core.%CONSTRUCTOR%.methods.%NAME% + if(IS_PROTO){ + (exports.virtual || (exports.virtual = {}))[key] = out; + // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME% + if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out); } } - - function close() { - checkForbiddenStates(); - if (!closed) { - closed = true; - if (takers.length) { - var arr = takers; - takers = []; - for (var i = 0, len = arr.length; i < len; i++) { - arr[i](END); - } - takers = []; - } - } + }; + // type bitmap + $export.F = 1; // forced + $export.G = 2; // global + $export.S = 4; // static + $export.P = 8; // proto + $export.B = 16; // bind + $export.W = 32; // wrap + $export.U = 64; // safe + $export.R = 128; // real proto method for `library` + module.exports = $export; + +/***/ }), +/* 21 */ +/***/ (function(module, exports) { + + module.exports = function(exec){ + try { + return !!exec(); + } catch(e){ + return true; } + }; - return { take: take, put: put, close: close, - get __takers__() { - return takers; - }, - get __closed__() { - return closed; - } - }; - } - - function eventChannel(subscribe) { - var buffer = arguments.length <= 1 || arguments[1] === undefined ? _buffers.buffers.none() : arguments[1]; - var matcher = arguments[2]; - - /** - should be if(typeof matcher !== undefined) instead? - see PR #273 for a background discussion - **/ - if (arguments.length > 2) { - (0, _utils.check)(matcher, _utils.is.func, 'Invalid match function passed to eventChannel'); - } +/***/ }), +/* 22 */ +/***/ (function(module, exports, __webpack_require__) { - var chan = channel(buffer); - var unsubscribe = subscribe(function (input) { - if (isEnd(input)) { - chan.close(); - } else if (!matcher || matcher(input)) { - chan.put(input); + 'use strict'; + var LIBRARY = __webpack_require__(46) + , $export = __webpack_require__(20) + , redefine = __webpack_require__(52) + , hide = __webpack_require__(5) + , has = __webpack_require__(8) + , Iterators = __webpack_require__(6) + , $iterCreate = __webpack_require__(44) + , setToStringTag = __webpack_require__(24) + , getPrototypeOf = __webpack_require__(49) + , ITERATOR = __webpack_require__(1)('iterator') + , BUGGY = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next` + , FF_ITERATOR = '@@iterator' + , KEYS = 'keys' + , VALUES = 'values'; + + var returnThis = function(){ return this; }; + + module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){ + $iterCreate(Constructor, NAME, next); + var getMethod = function(kind){ + if(!BUGGY && kind in proto)return proto[kind]; + switch(kind){ + case KEYS: return function keys(){ return new Constructor(this, kind); }; + case VALUES: return function values(){ return new Constructor(this, kind); }; + } return function entries(){ return new Constructor(this, kind); }; + }; + var TAG = NAME + ' Iterator' + , DEF_VALUES = DEFAULT == VALUES + , VALUES_BUG = false + , proto = Base.prototype + , $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT] + , $default = $native || getMethod(DEFAULT) + , $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined + , $anyNative = NAME == 'Array' ? proto.entries || $native : $native + , methods, key, IteratorPrototype; + // Fix native + if($anyNative){ + IteratorPrototype = getPrototypeOf($anyNative.call(new Base)); + if(IteratorPrototype !== Object.prototype){ + // Set @@toStringTag to native iterators + setToStringTag(IteratorPrototype, TAG, true); + // fix for some old engines + if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis); } - }); - - if (!_utils.is.func(unsubscribe)) { - throw new Error('in eventChannel: subscribe should return a function to unsubscribe'); } + // fix Array#{values, @@iterator}.name in V8 / FF + if(DEF_VALUES && $native && $native.name !== VALUES){ + VALUES_BUG = true; + $default = function values(){ return $native.call(this); }; + } + // Define iterator + if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){ + hide(proto, ITERATOR, $default); + } + // Plug for library + Iterators[NAME] = $default; + Iterators[TAG] = returnThis; + if(DEFAULT){ + methods = { + values: DEF_VALUES ? $default : getMethod(VALUES), + keys: IS_SET ? $default : getMethod(KEYS), + entries: $entries + }; + if(FORCED)for(key in methods){ + if(!(key in proto))redefine(proto, key, methods[key]); + } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods); + } + return methods; + }; +/***/ }), +/* 23 */ +/***/ (function(module, exports) { + + module.exports = function(bitmap, value){ return { - take: chan.take, - close: function close() { - if (!chan.__closed__) { - chan.close(); - unsubscribe(); - } - } + enumerable : !(bitmap & 1), + configurable: !(bitmap & 2), + writable : !(bitmap & 4), + value : value }; - } - /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5))) + }; -/***/ }, -/* 3 */ -/***/ function(module, exports, __webpack_require__) { +/***/ }), +/* 24 */ +/***/ (function(module, exports, __webpack_require__) { - 'use strict'; + var def = __webpack_require__(9).f + , has = __webpack_require__(8) + , TAG = __webpack_require__(1)('toStringTag'); - Object.defineProperty(exports, "__esModule", { - value: true - }); - exports.asEffect = undefined; - - var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); - - exports.take = take; - exports.takem = takem; - exports.put = put; - exports.race = race; - exports.call = call; - exports.apply = apply; - exports.cps = cps; - exports.fork = fork; - exports.spawn = spawn; - exports.join = join; - exports.cancel = cancel; - exports.select = select; - exports.actionChannel = actionChannel; - exports.cancelled = cancelled; - - var _utils = __webpack_require__(1); - - function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } - - var IO = (0, _utils.sym)('IO'); - var TAKE = 'TAKE'; - var PUT = 'PUT'; - var RACE = 'RACE'; - var CALL = 'CALL'; - var CPS = 'CPS'; - var FORK = 'FORK'; - var JOIN = 'JOIN'; - var CANCEL = 'CANCEL'; - var SELECT = 'SELECT'; - var ACTION_CHANNEL = 'ACTION_CHANNEL'; - var CANCELLED = 'CANCELLED'; - - var effect = function effect(type, payload) { - var _ref; - - return _ref = {}, _defineProperty(_ref, IO, true), _defineProperty(_ref, type, payload), _ref; + module.exports = function(it, tag, stat){ + if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag}); }; - function take(channel, pattern) { - if (arguments.length >= 2) { - (0, _utils.check)(channel, _utils.is.notUndef, 'take(channel, pattern): channel is undefined'); - (0, _utils.check)(channel, _utils.is.take, 'take(channel, pattern): argument ' + String(channel) + ' is not a valid channel (channel argument must have a take method)'); - (0, _utils.check)(pattern, _utils.is.notUndef, 'take(channel, pattern): pattern is undefined'); - (0, _utils.check)(pattern, _utils.is.pattern, 'take(channel, pattern): argument ' + String(pattern) + ' is not a valid pattern (pattern must be String | Function: a => boolean | Array)'); - } else if (arguments.length === 1) { - (0, _utils.check)(channel, _utils.is.notUndef, 'take(patternOrChannel): undefined argument'); - if (!_utils.is.take(channel)) { - if (_utils.is.pattern(channel)) { - pattern = channel; - channel = null; - } else { - throw new Error('take(patternOrChannel): argument ' + String(channel) + ' is not valid channel or a valid pattern'); - } - } else { - pattern = '*'; - } - } else { - pattern = '*'; - } - - return effect(TAKE, { channel: channel, pattern: pattern }); - } +/***/ }), +/* 25 */ +/***/ (function(module, exports, __webpack_require__) { - function takem() { - var eff = take.apply(undefined, arguments); - eff[TAKE].maybe = true; - return eff; - } + var global = __webpack_require__(2) + , SHARED = '__core-js_shared__' + , store = global[SHARED] || (global[SHARED] = {}); + module.exports = function(key){ + return store[key] || (store[key] = {}); + }; - function put(channel, action) { - if (arguments.length > 1) { - (0, _utils.check)(channel, _utils.is.notUndef, 'put(channel, action): argument channel is undefined'); - (0, _utils.check)(channel, _utils.is.put, 'put(channel, action): argument ' + channel + ' is not a valid channel (channel argument must have a put method)'); - (0, _utils.check)(action, _utils.is.notUndef, 'put(channel, action): argument action is undefined'); - } else { - (0, _utils.check)(channel, _utils.is.notUndef, 'put(action): argument action is undefined'); - action = channel; - channel = null; - } - return effect(PUT, { channel: channel, action: action }); - } +/***/ }), +/* 26 */ +/***/ (function(module, exports) { - put.sync = function () { - var eff = put.apply(undefined, arguments); - eff[PUT].sync = true; - return eff; + var id = 0 + , px = Math.random(); + module.exports = function(key){ + return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36)); }; - function race(effects) { - return effect(RACE, effects); - } +/***/ }), +/* 27 */ +/***/ (function(module, exports, __webpack_require__) { - function getFnCallDesc(meth, fn, args) { - (0, _utils.check)(fn, _utils.is.notUndef, meth + ': argument fn is undefined'); + 'use strict'; + var $at = __webpack_require__(53)(true); + + // 21.1.3.27 String.prototype[@@iterator]() + __webpack_require__(22)(String, 'String', function(iterated){ + this._t = String(iterated); // target + this._i = 0; // next index + // 21.1.5.2.1 %StringIteratorPrototype%.next() + }, function(){ + var O = this._t + , index = this._i + , point; + if(index >= O.length)return {value: undefined, done: true}; + point = $at(O, index); + this._i += point.length; + return {value: point, done: false}; + }); - var context = null; - if (_utils.is.array(fn)) { - var _fn = fn; +/***/ }), +/* 28 */ +/***/ (function(module, exports, __webpack_require__) { + + __webpack_require__(61); + var global = __webpack_require__(2) + , hide = __webpack_require__(5) + , Iterators = __webpack_require__(6) + , TO_STRING_TAG = __webpack_require__(1)('toStringTag'); + + for(var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++){ + var NAME = collections[i] + , Collection = global[NAME] + , proto = Collection && Collection.prototype; + if(proto && !proto[TO_STRING_TAG])hide(proto, TO_STRING_TAG, NAME); + Iterators[NAME] = Iterators.Array; + } - var _fn2 = _slicedToArray(_fn, 2); +/***/ }), +/* 29 */ +/***/ (function(module, exports, __webpack_require__) { - context = _fn2[0]; - fn = _fn2[1]; - } else if (fn.fn) { - var _fn3 = fn; - context = _fn3.context; - fn = _fn3.fn; - } - (0, _utils.check)(fn, _utils.is.func, meth + ': argument ' + fn + ' is not a function'); + module.exports = { "default": __webpack_require__(35), __esModule: true }; - return { context: context, fn: fn, args: args }; - } +/***/ }), +/* 30 */ +/***/ (function(module, exports, __webpack_require__) { - function call(fn) { - for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { - args[_key - 1] = arguments[_key]; - } + module.exports = { "default": __webpack_require__(36), __esModule: true }; - return effect(CALL, getFnCallDesc('call', fn, args)); - } +/***/ }), +/* 31 */ +/***/ (function(module, exports, __webpack_require__) { - function apply(context, fn) { - var args = arguments.length <= 2 || arguments[2] === undefined ? [] : arguments[2]; + "use strict"; - return effect(CALL, getFnCallDesc('apply', { context: context, fn: fn }, args)); - } + exports.__esModule = true; - function cps(fn) { - for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { - args[_key2 - 1] = arguments[_key2]; - } + var _defineProperty = __webpack_require__(30); - return effect(CPS, getFnCallDesc('cps', fn, args)); - } + var _defineProperty2 = _interopRequireDefault(_defineProperty); - function fork(fn) { - for (var _len3 = arguments.length, args = Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) { - args[_key3 - 1] = arguments[_key3]; + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + exports.default = function (obj, key, value) { + if (key in obj) { + (0, _defineProperty2.default)(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; } - return effect(FORK, getFnCallDesc('fork', fn, args)); - } + return obj; + }; - function spawn(fn) { - for (var _len4 = arguments.length, args = Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) { - args[_key4 - 1] = arguments[_key4]; - } +/***/ }), +/* 32 */ +/***/ (function(module, exports, __webpack_require__) { - var eff = fork.apply(undefined, [fn].concat(args)); - eff[FORK].detached = true; - return eff; - } + "use strict"; - var isForkedTask = function isForkedTask(task) { - return task[_utils.TASK]; - }; + exports.__esModule = true; - function join(task) { - (0, _utils.check)(task, _utils.is.notUndef, 'join(task): argument task is undefined'); - if (!isForkedTask(task)) { - throw new Error('join(task): argument ' + task + ' is not a valid Task object \n(HINT: if you are getting this errors in tests, consider using createMockTask from redux-saga/utils)'); - } + var _isIterable2 = __webpack_require__(29); - return effect(JOIN, task); - } + var _isIterable3 = _interopRequireDefault(_isIterable2); - function cancel(task) { - (0, _utils.check)(task, _utils.is.notUndef, 'cancel(task): argument task is undefined'); - if (!isForkedTask(task)) { - throw new Error('cancel(task): argument ' + task + ' is not a valid Task object \n(HINT: if you are getting this errors in tests, consider using createMockTask from redux-saga/utils)'); - } + var _getIterator2 = __webpack_require__(15); - return effect(CANCEL, task); - } + var _getIterator3 = _interopRequireDefault(_getIterator2); - function select(selector) { - for (var _len5 = arguments.length, args = Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) { - args[_key5 - 1] = arguments[_key5]; - } + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - if (arguments.length === 0) { - selector = _utils.ident; - } else { - (0, _utils.check)(select, _utils.is.notUndef, 'select(selector,[...]): argument selector is undefined'); - (0, _utils.check)(selector, _utils.is.func, 'select(selector,[...]): argument ' + selector + ' is not a function'); - } - return effect(SELECT, { selector: selector, args: args }); - } + exports.default = function () { + function sliceIterator(arr, i) { + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; - /** - channel(pattern, [buffer]) => creates an event channel for store actions - **/ - function actionChannel(pattern, buffer) { - (0, _utils.check)(pattern, _utils.is.notUndef, 'actionChannel(pattern,...): argument pattern is undefined'); - if (arguments.length > 1) { - (0, _utils.check)(buffer, _utils.is.notUndef, 'actionChannel(pattern, buffer): argument buffer is undefined'); - (0, _utils.check)(buffer, _utils.is.notUndef, 'actionChannel(pattern, buffer): argument ' + buffer + ' is not a valid buffer'); - } - return effect(ACTION_CHANNEL, { pattern: pattern, buffer: buffer }); - } + try { + for (var _i = (0, _getIterator3.default)(arr), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); - function cancelled() { - return effect(CANCELLED, {}); - } + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"]) _i["return"](); + } finally { + if (_d) throw _e; + } + } - var asEffect = exports.asEffect = { - take: function take(effect) { - return effect && effect[IO] && effect[TAKE]; - }, - put: function put(effect) { - return effect && effect[IO] && effect[PUT]; - }, - race: function race(effect) { - return effect && effect[IO] && effect[RACE]; - }, - call: function call(effect) { - return effect && effect[IO] && effect[CALL]; - }, - cps: function cps(effect) { - return effect && effect[IO] && effect[CPS]; - }, - fork: function fork(effect) { - return effect && effect[IO] && effect[FORK]; - }, - join: function join(effect) { - return effect && effect[IO] && effect[JOIN]; - }, - cancel: function cancel(effect) { - return effect && effect[IO] && effect[CANCEL]; - }, - select: function select(effect) { - return effect && effect[IO] && effect[SELECT]; - }, - actionChannel: function actionChannel(effect) { - return effect && effect[IO] && effect[ACTION_CHANNEL]; - }, - cancelled: function cancelled(effect) { - return effect && effect[IO] && effect[CANCELLED]; + return _arr; } - }; -/***/ }, -/* 4 */ -/***/ function(module, exports, __webpack_require__) { + return function (arr, i) { + if (Array.isArray(arr)) { + return arr; + } else if ((0, _isIterable3.default)(Object(arr))) { + return sliceIterator(arr, i); + } else { + throw new TypeError("Invalid attempt to destructure non-iterable instance"); + } + }; + }(); - 'use strict'; +/***/ }), +/* 33 */ +/***/ (function(module, exports, __webpack_require__) { - Object.defineProperty(exports, "__esModule", { - value: true - }); - exports.buffers = exports.BUFFER_OVERFLOW = undefined; + module.exports = __webpack_require__(63); - var _utils = __webpack_require__(1); - var BUFFER_OVERFLOW = exports.BUFFER_OVERFLOW = 'Channel\'s Buffer overflow!'; +/***/ }), +/* 34 */ +/***/ (function(module, exports, __webpack_require__) { - var ON_OVERFLOW_THROW = 1; - var ON_OVERFLOW_DROP = 2; - var ON_OVERFLOW_SLIDE = 3; + __webpack_require__(28); + __webpack_require__(27); + module.exports = __webpack_require__(59); - var zeroBuffer = { isEmpty: _utils.kTrue, put: _utils.noop, take: _utils.noop }; +/***/ }), +/* 35 */ +/***/ (function(module, exports, __webpack_require__) { - function ringBuffer() { - var limit = arguments.length <= 0 || arguments[0] === undefined ? 10 : arguments[0]; - var overflowAction = arguments[1]; + __webpack_require__(28); + __webpack_require__(27); + module.exports = __webpack_require__(60); - var arr = new Array(limit); - var length = 0; - var pushIndex = 0; - var popIndex = 0; - return { - isEmpty: function isEmpty() { - return length == 0; - }, - put: function put(it) { - if (length < limit) { - arr[pushIndex] = it; - pushIndex = (pushIndex + 1) % limit; - length++; - } else { - switch (overflowAction) { - case ON_OVERFLOW_THROW: - throw new Error(BUFFER_OVERFLOW); - case ON_OVERFLOW_SLIDE: - arr[pushIndex] = it; - pushIndex = (pushIndex + 1) % limit; - popIndex = pushIndex; - break; - default: - // DROP - } - } - }, - take: function take() { - if (length != 0) { - var it = arr[popIndex]; - arr[popIndex] = null; - length--; - popIndex = (popIndex + 1) % limit; - return it; - } - } - }; - } +/***/ }), +/* 36 */ +/***/ (function(module, exports, __webpack_require__) { - var buffers = exports.buffers = { - none: function none() { - return zeroBuffer; - }, - fixed: function fixed(limit) { - return ringBuffer(limit, ON_OVERFLOW_THROW); - }, - dropping: function dropping(limit) { - return ringBuffer(limit, ON_OVERFLOW_DROP); - }, - sliding: function sliding(limit) { - return ringBuffer(limit, ON_OVERFLOW_SLIDE); - } + __webpack_require__(62); + var $Object = __webpack_require__(3).Object; + module.exports = function defineProperty(it, key, desc){ + return $Object.defineProperty(it, key, desc); }; -/***/ }, -/* 5 */ -/***/ function(module, exports) { - - // shim for using process in browser - var process = module.exports = {}; - - // cached from whatever global is present so that test runners that stub it - // don't break things. But we need to wrap it in a try catch in case it is - // wrapped in strict mode code which doesn't define any globals. It's inside a - // function because try/catches deoptimize in certain engines. +/***/ }), +/* 37 */ +/***/ (function(module, exports) { - var cachedSetTimeout; - var cachedClearTimeout; - - function defaultSetTimout() { - throw new Error('setTimeout has not been defined'); - } - function defaultClearTimeout () { - throw new Error('clearTimeout has not been defined'); - } - (function () { - try { - if (typeof setTimeout === 'function') { - cachedSetTimeout = setTimeout; - } else { - cachedSetTimeout = defaultSetTimout; - } - } catch (e) { - cachedSetTimeout = defaultSetTimout; - } - try { - if (typeof clearTimeout === 'function') { - cachedClearTimeout = clearTimeout; - } else { - cachedClearTimeout = defaultClearTimeout; - } - } catch (e) { - cachedClearTimeout = defaultClearTimeout; - } - } ()) - function runTimeout(fun) { - if (cachedSetTimeout === setTimeout) { - //normal enviroments in sane situations - return setTimeout(fun, 0); - } - // if setTimeout wasn't available but was latter defined - if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { - cachedSetTimeout = setTimeout; - return setTimeout(fun, 0); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedSetTimeout(fun, 0); - } catch(e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedSetTimeout.call(null, fun, 0); - } catch(e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error - return cachedSetTimeout.call(this, fun, 0); - } - } - - - } - function runClearTimeout(marker) { - if (cachedClearTimeout === clearTimeout) { - //normal enviroments in sane situations - return clearTimeout(marker); - } - // if clearTimeout wasn't available but was latter defined - if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { - cachedClearTimeout = clearTimeout; - return clearTimeout(marker); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedClearTimeout(marker); - } catch (e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedClearTimeout.call(null, marker); - } catch (e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. - // Some versions of I.E. have different rules for clearTimeout vs setTimeout - return cachedClearTimeout.call(this, marker); - } - } - - - - } - var queue = []; - var draining = false; - var currentQueue; - var queueIndex = -1; - - function cleanUpNextTick() { - if (!draining || !currentQueue) { - return; - } - draining = false; - if (currentQueue.length) { - queue = currentQueue.concat(queue); - } else { - queueIndex = -1; - } - if (queue.length) { - drainQueue(); - } - } - - function drainQueue() { - if (draining) { - return; - } - var timeout = runTimeout(cleanUpNextTick); - draining = true; - - var len = queue.length; - while(len) { - currentQueue = queue; - queue = []; - while (++queueIndex < len) { - if (currentQueue) { - currentQueue[queueIndex].run(); - } - } - queueIndex = -1; - len = queue.length; - } - currentQueue = null; - draining = false; - runClearTimeout(timeout); - } - - process.nextTick = function (fun) { - var args = new Array(arguments.length - 1); - if (arguments.length > 1) { - for (var i = 1; i < arguments.length; i++) { - args[i - 1] = arguments[i]; - } - } - queue.push(new Item(fun, args)); - if (queue.length === 1 && !draining) { - runTimeout(drainQueue); - } + module.exports = function(it){ + if(typeof it != 'function')throw TypeError(it + ' is not a function!'); + return it; }; - // v8 likes predictible objects - function Item(fun, array) { - this.fun = fun; - this.array = array; - } - Item.prototype.run = function () { - this.fun.apply(null, this.array); - }; - process.title = 'browser'; - process.browser = true; - process.env = {}; - process.argv = []; - process.version = ''; // empty string to avoid regexp issues - process.versions = {}; - - function noop() {} - - process.on = noop; - process.addListener = noop; - process.once = noop; - process.off = noop; - process.removeListener = noop; - process.removeAllListeners = noop; - process.emit = noop; - - process.binding = function (name) { - throw new Error('process.binding is not supported'); +/***/ }), +/* 38 */ +/***/ (function(module, exports) { + + module.exports = function(){ /* empty */ }; + +/***/ }), +/* 39 */ +/***/ (function(module, exports, __webpack_require__) { + + // false -> Array#indexOf + // true -> Array#includes + var toIObject = __webpack_require__(14) + , toLength = __webpack_require__(55) + , toIndex = __webpack_require__(54); + module.exports = function(IS_INCLUDES){ + return function($this, el, fromIndex){ + var O = toIObject($this) + , length = toLength(O.length) + , index = toIndex(fromIndex, length) + , value; + // Array#includes uses SameValueZero equality algorithm + if(IS_INCLUDES && el != el)while(length > index){ + value = O[index++]; + if(value != value)return true; + // Array#toIndex ignores holes, Array#includes - not + } else for(;length > index; index++)if(IS_INCLUDES || index in O){ + if(O[index] === el)return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; }; - process.cwd = function () { return '/' }; - process.chdir = function (dir) { - throw new Error('process.chdir is not supported'); +/***/ }), +/* 40 */ +/***/ (function(module, exports, __webpack_require__) { + + // optional / simple context binding + var aFunction = __webpack_require__(37); + module.exports = function(fn, that, length){ + aFunction(fn); + if(that === undefined)return fn; + switch(length){ + case 1: return function(a){ + return fn.call(that, a); + }; + case 2: return function(a, b){ + return fn.call(that, a, b); + }; + case 3: return function(a, b, c){ + return fn.call(that, a, b, c); + }; + } + return function(/* ...args */){ + return fn.apply(that, arguments); + }; }; - process.umask = function() { return 0; }; - -/***/ }, -/* 6 */ -/***/ function(module, exports, __webpack_require__) { +/***/ }), +/* 41 */ +/***/ (function(module, exports, __webpack_require__) { - 'use strict'; - - Object.defineProperty(exports, "__esModule", { - value: true - }); + module.exports = __webpack_require__(2).document && document.documentElement; - var _io = __webpack_require__(3); +/***/ }), +/* 42 */ +/***/ (function(module, exports, __webpack_require__) { - Object.defineProperty(exports, 'take', { - enumerable: true, - get: function get() { - return _io.take; - } - }); - Object.defineProperty(exports, 'takem', { - enumerable: true, - get: function get() { - return _io.takem; - } - }); - Object.defineProperty(exports, 'put', { - enumerable: true, - get: function get() { - return _io.put; - } - }); - Object.defineProperty(exports, 'race', { - enumerable: true, - get: function get() { - return _io.race; - } - }); - Object.defineProperty(exports, 'call', { - enumerable: true, - get: function get() { - return _io.call; - } - }); - Object.defineProperty(exports, 'apply', { - enumerable: true, - get: function get() { - return _io.apply; - } - }); - Object.defineProperty(exports, 'cps', { - enumerable: true, - get: function get() { - return _io.cps; - } - }); - Object.defineProperty(exports, 'fork', { - enumerable: true, - get: function get() { - return _io.fork; - } - }); - Object.defineProperty(exports, 'spawn', { - enumerable: true, - get: function get() { - return _io.spawn; - } - }); - Object.defineProperty(exports, 'join', { - enumerable: true, - get: function get() { - return _io.join; - } - }); - Object.defineProperty(exports, 'cancel', { - enumerable: true, - get: function get() { - return _io.cancel; - } - }); - Object.defineProperty(exports, 'select', { - enumerable: true, - get: function get() { - return _io.select; - } - }); - Object.defineProperty(exports, 'actionChannel', { - enumerable: true, - get: function get() { - return _io.actionChannel; - } - }); - Object.defineProperty(exports, 'cancelled', { - enumerable: true, - get: function get() { - return _io.cancelled; - } + module.exports = !__webpack_require__(4) && !__webpack_require__(21)(function(){ + return Object.defineProperty(__webpack_require__(18)('div'), 'a', {get: function(){ return 7; }}).a != 7; }); -/***/ }, -/* 7 */ -/***/ function(module, exports, __webpack_require__) { - - /* WEBPACK VAR INJECTION */(function(process) {'use strict'; +/***/ }), +/* 43 */ +/***/ (function(module, exports, __webpack_require__) { - Object.defineProperty(exports, "__esModule", { - value: true - }); - exports.TASK_CANCEL = exports.CHANNEL_END = exports.NOT_ITERATOR_ERROR = undefined; - exports.default = proc; - - var _utils = __webpack_require__(1); + // fallback for non-array-like ES3 and non-enumerable old V8 strings + var cof = __webpack_require__(17); + module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){ + return cof(it) == 'String' ? it.split('') : Object(it); + }; - var _asap = __webpack_require__(10); +/***/ }), +/* 44 */ +/***/ (function(module, exports, __webpack_require__) { - var _asap2 = _interopRequireDefault(_asap); + 'use strict'; + var create = __webpack_require__(47) + , descriptor = __webpack_require__(23) + , setToStringTag = __webpack_require__(24) + , IteratorPrototype = {}; - var _io = __webpack_require__(3); + // 25.1.2.1.1 %IteratorPrototype%[@@iterator]() + __webpack_require__(5)(IteratorPrototype, __webpack_require__(1)('iterator'), function(){ return this; }); - var _channel = __webpack_require__(2); + module.exports = function(Constructor, NAME, next){ + Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)}); + setToStringTag(Constructor, NAME + ' Iterator'); + }; - var _buffers = __webpack_require__(4); +/***/ }), +/* 45 */ +/***/ (function(module, exports) { - function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + module.exports = function(done, value){ + return {value: value, done: !!done}; + }; - 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); } return obj; } +/***/ }), +/* 46 */ +/***/ (function(module, exports) { + + module.exports = true; + +/***/ }), +/* 47 */ +/***/ (function(module, exports, __webpack_require__) { + + // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties]) + var anObject = __webpack_require__(7) + , dPs = __webpack_require__(48) + , enumBugKeys = __webpack_require__(19) + , IE_PROTO = __webpack_require__(12)('IE_PROTO') + , Empty = function(){ /* empty */ } + , PROTOTYPE = 'prototype'; + + // Create object with fake `null` prototype: use iframe Object with cleared prototype + var createDict = function(){ + // Thrash, waste and sodomy: IE GC bug + var iframe = __webpack_require__(18)('iframe') + , i = enumBugKeys.length + , lt = '<' + , gt = '>' + , iframeDocument; + iframe.style.display = 'none'; + __webpack_require__(41).appendChild(iframe); + iframe.src = 'javascript:'; // eslint-disable-line no-script-url + // createDict = iframe.contentWindow.Object; + // html.removeChild(iframe); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt); + iframeDocument.close(); + createDict = iframeDocument.F; + while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]]; + return createDict(); + }; - function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } + module.exports = Object.create || function create(O, Properties){ + var result; + if(O !== null){ + Empty[PROTOTYPE] = anObject(O); + result = new Empty; + Empty[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO] = O; + } else result = createDict(); + return Properties === undefined ? result : dPs(result, Properties); + }; - function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } - var isDev = process.env.NODE_ENV === 'development'; +/***/ }), +/* 48 */ +/***/ (function(module, exports, __webpack_require__) { - var NOT_ITERATOR_ERROR = exports.NOT_ITERATOR_ERROR = 'proc first argument (Saga function result) must be an iterator'; + var dP = __webpack_require__(9) + , anObject = __webpack_require__(7) + , getKeys = __webpack_require__(51); - var nextEffectId = (0, _utils.autoInc)(); - var CHANNEL_END = exports.CHANNEL_END = { - toString: function toString() { - return '@@redux-saga/CHANNEL_END'; - } - }; - var TASK_CANCEL = exports.TASK_CANCEL = { - toString: function toString() { - return '@@redux-saga/TASK_CANCEL'; - } + module.exports = __webpack_require__(4) ? Object.defineProperties : function defineProperties(O, Properties){ + anObject(O); + var keys = getKeys(Properties) + , length = keys.length + , i = 0 + , P; + while(length > i)dP.f(O, P = keys[i++], Properties[P]); + return O; }; - var matchers = { - wildcard: function wildcard() { - return _utils.kTrue; - }, - default: function _default(pattern) { - return function (input) { - return input.type === pattern; - }; - }, - array: function array(patterns) { - return function (input) { - return patterns.some(function (p) { - return p === input.type; - }); - }; - }, - predicate: function predicate(_predicate) { - return function (input) { - return _predicate(input); - }; - } +/***/ }), +/* 49 */ +/***/ (function(module, exports, __webpack_require__) { + + // 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O) + var has = __webpack_require__(8) + , toObject = __webpack_require__(56) + , IE_PROTO = __webpack_require__(12)('IE_PROTO') + , ObjectProto = Object.prototype; + + module.exports = Object.getPrototypeOf || function(O){ + O = toObject(O); + if(has(O, IE_PROTO))return O[IE_PROTO]; + if(typeof O.constructor == 'function' && O instanceof O.constructor){ + return O.constructor.prototype; + } return O instanceof Object ? ObjectProto : null; }; - function matcher(pattern) { - return (pattern === '*' ? matchers.wildcard : _utils.is.array(pattern) ? matchers.array : _utils.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 - We model this using the concept of Parent task && main Task - main task is the main flow of the current Generator, the parent tasks is the - aggregation of the main tasks + all its forked tasks. - Thus the whole model represents an execution tree with multiple branches (vs the - linear execution tree in sequential (non parallel) programming) - - A parent tasks has the following semantics - - It completes iff all its forks either complete or all cancelled - - If it's cancelled, all forks are cancelled as well - - 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 = void 0, - completed = false; - addTask(mainTask); - - function abort(err) { - cancelAll(); - cb(err, true); - } +/***/ }), +/* 50 */ +/***/ (function(module, exports, __webpack_require__) { + + var has = __webpack_require__(8) + , toIObject = __webpack_require__(14) + , arrayIndexOf = __webpack_require__(39)(false) + , IE_PROTO = __webpack_require__(12)('IE_PROTO'); + + module.exports = function(object, names){ + var O = toIObject(object) + , i = 0 + , result = [] + , key; + for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key); + // Don't enum bug & hidden keys + while(names.length > i)if(has(O, key = names[i++])){ + ~arrayIndexOf(result, key) || result.push(key); + } + return result; + }; - function addTask(task) { - tasks.push(task); - task.cont = function (res, isErr) { - if (completed) { - return; - } +/***/ }), +/* 51 */ +/***/ (function(module, exports, __webpack_require__) { - (0, _utils.remove)(tasks, task); - task.cont = _utils.noop; - if (isErr) { - abort(res); - } else { - if (task === mainTask) { - result = res; - } - if (!tasks.length) { - completed = true; - cb(result); - } - } - }; - // task.cont.cancel = task.cancel - } + // 19.1.2.14 / 15.2.3.14 Object.keys(O) + var $keys = __webpack_require__(50) + , enumBugKeys = __webpack_require__(19); - function cancelAll() { - if (completed) { - return; - } - completed = true; - tasks.forEach(function (t) { - t.cont = _utils.noop; - t.cancel(); - }); - tasks = []; - } + module.exports = Object.keys || function keys(O){ + return $keys(O, enumBugKeys); + }; - return { - addTask: addTask, - cancelAll: cancelAll, - abort: abort, - getTasks: function getTasks() { - return tasks; - }, - taskNames: function taskNames() { - return tasks.map(function (t) { - return t.name; - }); - } +/***/ }), +/* 52 */ +/***/ (function(module, exports, __webpack_require__) { + + module.exports = __webpack_require__(5); + +/***/ }), +/* 53 */ +/***/ (function(module, exports, __webpack_require__) { + + var toInteger = __webpack_require__(13) + , defined = __webpack_require__(10); + // true -> String#at + // false -> String#codePointAt + module.exports = function(TO_STRING){ + return function(that, pos){ + var s = String(defined(that)) + , i = toInteger(pos) + , l = s.length + , a, b; + if(i < 0 || i >= l)return TO_STRING ? '' : undefined; + a = s.charCodeAt(i); + return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff + ? TO_STRING ? s.charAt(i) : a + : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000; }; - } - - function proc(iterator) { - var subscribe = arguments.length <= 1 || arguments[1] === undefined ? function () { - return _utils.noop; - } : arguments[1]; - var dispatch = arguments.length <= 2 || arguments[2] === undefined ? _utils.noop : arguments[2]; - var getState = arguments.length <= 3 || arguments[3] === undefined ? _utils.noop : arguments[3]; - var options = arguments.length <= 4 || arguments[4] === undefined ? {} : arguments[4]; - var parentEffectId = arguments.length <= 5 || arguments[5] === undefined ? 0 : arguments[5]; - var name = arguments.length <= 6 || arguments[6] === undefined ? 'anonymous' : arguments[6]; - var cont = arguments[7]; - - (0, _utils.check)(iterator, _utils.is.iterator, NOT_ITERATOR_ERROR); - - var sagaMonitor = options.sagaMonitor; - var logger = options.logger; - - var log = logger || _utils.log; - var stdChannel = (0, _channel.eventChannel)(subscribe); - /** - 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 = _utils.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, 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. - Cancellation propagates down to the whole execution tree holded by this Parent task - 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 - Tasks can be Cancelled but still Running - **/ - if (iterator._isRunning && !iterator._isCancelled) { - iterator._isCancelled = true; - taskQueue.cancelAll(); - /** - Ending with a Never result will propagate the Cancellation to all joiners - **/ - end(TASK_CANCEL); - } - } - /** - 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; - - // 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'); - } +/***/ }), +/* 54 */ +/***/ (function(module, exports, __webpack_require__) { - try { - var result = void 0; - if (isErr) { - result = iterator.throw(arg); - } else if (arg === TASK_CANCEL) { - /** - getting TASK_CANCEL autoamtically cancels the main task - We can get this value here - - By cancelling the parent task manually - - By joining a Cancelled task - **/ - mainTask.isCancelled = true; - /** - 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 - Thill will jump to the finally block - **/ - result = _utils.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 = _utils.is.func(iterator.return) ? iterator.return() : { done: true }; - } else { - result = iterator.next(arg); - } + var toInteger = __webpack_require__(13) + , max = Math.max + , min = Math.min; + module.exports = function(index, length){ + index = toInteger(index); + return index < 0 ? max(index + length, 0) : min(index, length); + }; - if (!result.done) { - runEffect(result.value, parentEffectId, '', next); - } else { - /** - This Generator has ended, terminate the main task and notify the fork queue - **/ - mainTask.isMainRunning = false; - mainTask.cont && mainTask.cont(result.value); - } - } catch (error) { - if (mainTask.isCancelled) { - log('error', 'uncaught at ' + name, error.message); - } - mainTask.isMainRunning = false; - mainTask.cont(error, true); - } - } +/***/ }), +/* 55 */ +/***/ (function(module, exports, __webpack_require__) { - function end(result, isErr) { - iterator._isRunning = false; - stdChannel.close(); - if (!isErr) { - if (result === TASK_CANCEL && isDev) { - log('info', name + ' has been cancelled', ''); - } - iterator._result = result; - iterator._deferredEnd && iterator._deferredEnd.resolve(result); - } else { - if (result instanceof Error) { - result.sagaStack = 'at ' + name + ' \n ' + (result.sagaStack || result.stack); - } - if (!task.cont) { - log('error', 'uncaught', result.sagaStack || result.stack); - } - 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 = null; - } + // 7.1.15 ToLength + var toInteger = __webpack_require__(13) + , min = Math.min; + module.exports = function(it){ + return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991 + }; - function runEffect(effect, parentEffectId) { - var label = arguments.length <= 2 || arguments[2] === undefined ? '' : arguments[2]; - var cb = arguments[3]; +/***/ }), +/* 56 */ +/***/ (function(module, exports, __webpack_require__) { - var effectId = nextEffectId(); - sagaMonitor && sagaMonitor.effectTriggered({ effectId: effectId, parentEffectId: parentEffectId, label: label, effect: effect }); + // 7.1.13 ToObject(argument) + var defined = __webpack_require__(10); + module.exports = function(it){ + return Object(defined(it)); + }; - /** - 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 = void 0; +/***/ }), +/* 57 */ +/***/ (function(module, exports, __webpack_require__) { + + // 7.1.1 ToPrimitive(input [, PreferredType]) + var isObject = __webpack_require__(11); + // instead of the ES6 spec version, we didn't implement @@toPrimitive case + // and the second argument - flag - preferred type is a string + module.exports = function(it, S){ + if(!isObject(it))return it; + var fn, val; + if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val; + if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val; + if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val; + throw TypeError("Can't convert object to primitive value"); + }; - // Completion callback passed to the appropriate effect runner - function currCb(res, isErr) { - if (effectSettled) { - return; - } +/***/ }), +/* 58 */ +/***/ (function(module, exports, __webpack_require__) { + + var classof = __webpack_require__(16) + , ITERATOR = __webpack_require__(1)('iterator') + , Iterators = __webpack_require__(6); + module.exports = __webpack_require__(3).getIteratorMethod = function(it){ + if(it != undefined)return it[ITERATOR] + || it['@@iterator'] + || Iterators[classof(it)]; + }; - effectSettled = true; - cb.cancel = _utils.noop; // defensive measure - if (sagaMonitor) { - isErr ? sagaMonitor.effectRejected(effectId, res) : sagaMonitor.effectResolved(effectId, res); - } +/***/ }), +/* 59 */ +/***/ (function(module, exports, __webpack_require__) { - cb(res, isErr); - } - // tracks down the current cancel - currCb.cancel = _utils.noop; - - // setup cancellation logic on the parent cb - cb.cancel = function () { - // prevents cancelling an already completed effect - if (effectSettled) { - return; - } + var anObject = __webpack_require__(7) + , get = __webpack_require__(58); + module.exports = __webpack_require__(3).getIterator = function(it){ + var iterFn = get(it); + if(typeof iterFn != 'function')throw TypeError(it + ' is not iterable!'); + return anObject(iterFn.call(it)); + }; - 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) { - log('error', 'uncaught at ' + name, err.message); - } - currCb.cancel = _utils.noop; // defensive measure +/***/ }), +/* 60 */ +/***/ (function(module, exports, __webpack_require__) { + + var classof = __webpack_require__(16) + , ITERATOR = __webpack_require__(1)('iterator') + , Iterators = __webpack_require__(6); + module.exports = __webpack_require__(3).isIterable = function(it){ + var O = Object(it); + return O[ITERATOR] !== undefined + || '@@iterator' in O + || Iterators.hasOwnProperty(classof(O)); + }; - sagaMonitor && sagaMonitor.effectCancelled(effectId); - }; +/***/ }), +/* 61 */ +/***/ (function(module, exports, __webpack_require__) { - /** - each effect runner must attach its own logic of cancellation to the provided callback - it allows this generator to propagate cancellation downward. - ATTENTION! effect runners must setup the cancel logic by setting cb.cancel = [cancelMethod] - And the setup must occur before calling the callback - This is a sort of inversion of control: called async functions are responsible - of completing the flow by calling the provided continuation; while caller functions - are responsible for aborting the current flow by calling the attached cancel function - Library users can attach their own cancellation logic to promises by defining a - promise[CANCEL] method in their returned promises - ATTENTION! calling cancel must have no effect on an already completed or cancelled effect - **/ - var data = void 0; - return ( - // Non declarative effect - _utils.is.promise(effect) ? resolvePromise(effect, currCb) : _utils.is.iterator(effect) ? resolveIterator(effect, effectId, name, currCb) - - // declarative effects - : _utils.is.array(effect) ? runParallelEffect(effect, effectId, currCb) : _utils.is.notUndef(data = _io.asEffect.take(effect)) ? runTakeEffect(data, currCb) : _utils.is.notUndef(data = _io.asEffect.put(effect)) ? runPutEffect(data, currCb) : _utils.is.notUndef(data = _io.asEffect.race(effect)) ? runRaceEffect(data, effectId, currCb) : _utils.is.notUndef(data = _io.asEffect.call(effect)) ? runCallEffect(data, effectId, currCb) : _utils.is.notUndef(data = _io.asEffect.cps(effect)) ? runCPSEffect(data, currCb) : _utils.is.notUndef(data = _io.asEffect.fork(effect)) ? runForkEffect(data, effectId, currCb) : _utils.is.notUndef(data = _io.asEffect.join(effect)) ? runJoinEffect(data, currCb) : _utils.is.notUndef(data = _io.asEffect.cancel(effect)) ? runCancelEffect(data, currCb) : _utils.is.notUndef(data = _io.asEffect.select(effect)) ? runSelectEffect(data, currCb) : _utils.is.notUndef(data = _io.asEffect.actionChannel(effect)) ? runChannelEffect(data, currCb) : _utils.is.notUndef(data = _io.asEffect.cancelled(effect)) ? runCancelledEffect(data, currCb) : /* anything else returned as is */currCb(effect) - ); + 'use strict'; + var addToUnscopables = __webpack_require__(38) + , step = __webpack_require__(45) + , Iterators = __webpack_require__(6) + , toIObject = __webpack_require__(14); + + // 22.1.3.4 Array.prototype.entries() + // 22.1.3.13 Array.prototype.keys() + // 22.1.3.29 Array.prototype.values() + // 22.1.3.30 Array.prototype[@@iterator]() + module.exports = __webpack_require__(22)(Array, 'Array', function(iterated, kind){ + this._t = toIObject(iterated); // target + this._i = 0; // next index + this._k = kind; // kind + // 22.1.5.2.1 %ArrayIteratorPrototype%.next() + }, function(){ + var O = this._t + , kind = this._k + , index = this._i++; + if(!O || index >= O.length){ + this._t = undefined; + return step(1); + } + if(kind == 'keys' )return step(0, index); + if(kind == 'values')return step(0, O[index]); + return step(0, [index, O[index]]); + }, 'values'); + + // argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7) + Iterators.Arguments = Iterators.Array; + + addToUnscopables('keys'); + addToUnscopables('values'); + addToUnscopables('entries'); + +/***/ }), +/* 62 */ +/***/ (function(module, exports, __webpack_require__) { + + var $export = __webpack_require__(20); + // 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes) + $export($export.S + $export.F * !__webpack_require__(4), 'Object', {defineProperty: __webpack_require__(9).f}); + +/***/ }), +/* 63 */ +/***/ (function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(global) {// This method of obtaining a reference to the global object needs to be + // kept identical to the way it is obtained in runtime.js + var g = + typeof global === "object" ? global : + typeof window === "object" ? window : + typeof self === "object" ? self : this; + + // Use `getOwnPropertyNames` because not all browsers support calling + // `hasOwnProperty` on the global `self` object in a worker. See #183. + var hadRuntime = g.regeneratorRuntime && + Object.getOwnPropertyNames(g).indexOf("regeneratorRuntime") >= 0; + + // Save the old regeneratorRuntime in case it needs to be restored later. + var oldRuntime = hadRuntime && g.regeneratorRuntime; + + // Force reevalutation of runtime.js. + g.regeneratorRuntime = undefined; + + module.exports = __webpack_require__(64); + + if (hadRuntime) { + // Restore the original runtime. + g.regeneratorRuntime = oldRuntime; + } else { + // Remove the global property added by runtime.js. + try { + delete g.regeneratorRuntime; + } catch(e) { + g.regeneratorRuntime = undefined; } + } - function resolvePromise(promise, cb) { - var cancelPromise = promise[_utils.CANCEL]; - if (typeof cancelPromise === 'function') { - cb.cancel = cancelPromise; - } - promise.then(cb, function (error) { - return cb(error, true); - }); - } + /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) - function resolveIterator(iterator, effectId, name, cb) { - proc(iterator, subscribe, dispatch, getState, options, effectId, name, cb); - } +/***/ }), +/* 64 */ +/***/ (function(module, exports) { - function runTakeEffect(_ref, cb) { - var channel = _ref.channel; - var pattern = _ref.pattern; - var maybe = _ref.maybe; + /* WEBPACK VAR INJECTION */(function(global) {/** + * Copyright (c) 2014, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * https://raw.github.com/facebook/regenerator/master/LICENSE file. An + * additional grant of patent rights can be found in the PATENTS file in + * the same directory. + */ - channel = channel || stdChannel; - var takeCb = function takeCb(inp) { - return inp instanceof Error ? cb(inp, true) : (0, _channel.isEnd)(inp) && !maybe ? cb(CHANNEL_END) : cb(inp); - }; + !(function(global) { + "use strict"; + + var Op = Object.prototype; + var hasOwn = Op.hasOwnProperty; + var undefined; // More compressible than void 0. + var $Symbol = typeof Symbol === "function" ? Symbol : {}; + var iteratorSymbol = $Symbol.iterator || "@@iterator"; + var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator"; + var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; + + var inModule = typeof module === "object"; + var runtime = global.regeneratorRuntime; + if (runtime) { + if (inModule) { + // If regeneratorRuntime is defined globally and we're in a module, + // make the exports object identical to regeneratorRuntime. + module.exports = runtime; + } + // Don't bother evaluating the rest of this file if the runtime was + // already defined globally. + return; + } + + // Define the runtime globally (as expected by generated code) as either + // module.exports (if we're in a module) or a new, empty object. + runtime = global.regeneratorRuntime = inModule ? module.exports : {}; + + function wrap(innerFn, outerFn, self, tryLocsList) { + // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator. + var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator; + var generator = Object.create(protoGenerator.prototype); + var context = new Context(tryLocsList || []); + + // The ._invoke method unifies the implementations of the .next, + // .throw, and .return methods. + generator._invoke = makeInvokeMethod(innerFn, self, context); + + return generator; + } + runtime.wrap = wrap; + + // Try/catch helper to minimize deoptimizations. Returns a completion + // record like context.tryEntries[i].completion. This interface could + // have been (and was previously) designed to take a closure to be + // invoked without arguments, but in all the cases we care about we + // already have an existing method we want to call, so there's no need + // to create a new function object. We can even get away with assuming + // the method takes exactly one argument, since that happens to be true + // in every case, so we don't have to touch the arguments object. The + // only additional allocation required is the completion record, which + // has a stable shape and so hopefully should be cheap to allocate. + function tryCatch(fn, obj, arg) { try { - channel.take(takeCb, matcher(pattern)); + return { type: "normal", arg: fn.call(obj, arg) }; } catch (err) { - return cb(err, true); + return { type: "throw", arg: err }; } - cb.cancel = takeCb.cancel; } - function runPutEffect(_ref2, cb) { - var channel = _ref2.channel; - var action = _ref2.action; - var sync = _ref2.sync; - - /* - Use a reentrant lock `asap` to flatten all nested dispatches - If this put cause another Saga to take this action an then immediately - put an action that will be taken by this Saga. Then the outer Saga will miss - the action from the inner Saga b/c this put has not yet returned. - */ - (0, _asap2.default)(function () { - var result = void 0; - try { - result = (channel ? channel.put : dispatch)(action); - } catch (error) { - return cb(error, true); - } + var GenStateSuspendedStart = "suspendedStart"; + var GenStateSuspendedYield = "suspendedYield"; + var GenStateExecuting = "executing"; + var GenStateCompleted = "completed"; + + // Returning this object from the innerFn has the same effect as + // breaking out of the dispatch switch statement. + var ContinueSentinel = {}; + + // Dummy constructor functions that we use as the .constructor and + // .constructor.prototype properties for functions that return Generator + // objects. For full spec compliance, you may wish to configure your + // minifier not to mangle the names of these two functions. + function Generator() {} + function GeneratorFunction() {} + function GeneratorFunctionPrototype() {} + + // This is a polyfill for %IteratorPrototype% for environments that + // don't natively support it. + var IteratorPrototype = {}; + IteratorPrototype[iteratorSymbol] = function () { + return this; + }; - if (sync && _utils.is.promise(result)) { - resolvePromise(result, cb); - } else { - return cb(result); - } + var getProto = Object.getPrototypeOf; + var NativeIteratorPrototype = getProto && getProto(getProto(values([]))); + if (NativeIteratorPrototype && + NativeIteratorPrototype !== Op && + hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) { + // This environment has a native %IteratorPrototype%; use it instead + // of the polyfill. + IteratorPrototype = NativeIteratorPrototype; + } + + var Gp = GeneratorFunctionPrototype.prototype = + Generator.prototype = Object.create(IteratorPrototype); + GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype; + GeneratorFunctionPrototype.constructor = GeneratorFunction; + GeneratorFunctionPrototype[toStringTagSymbol] = + GeneratorFunction.displayName = "GeneratorFunction"; + + // Helper for defining the .next, .throw, and .return methods of the + // Iterator interface in terms of a single ._invoke method. + function defineIteratorMethods(prototype) { + ["next", "throw", "return"].forEach(function(method) { + prototype[method] = function(arg) { + return this._invoke(method, arg); + }; }); - // Put effects are non cancellables } - function runCallEffect(_ref3, effectId, cb) { - var context = _ref3.context; - var fn = _ref3.fn; - var args = _ref3.args; + runtime.isGeneratorFunction = function(genFun) { + var ctor = typeof genFun === "function" && genFun.constructor; + return ctor + ? ctor === GeneratorFunction || + // For the native GeneratorFunction constructor, the best we can + // do is to check its .name property. + (ctor.displayName || ctor.name) === "GeneratorFunction" + : false; + }; - var result = void 0; - // catch synchronous failures; see #152 - try { - result = fn.apply(context, args); - } catch (error) { - return cb(error, true); + runtime.mark = function(genFun) { + if (Object.setPrototypeOf) { + Object.setPrototypeOf(genFun, GeneratorFunctionPrototype); + } else { + genFun.__proto__ = GeneratorFunctionPrototype; + if (!(toStringTagSymbol in genFun)) { + genFun[toStringTagSymbol] = "GeneratorFunction"; + } } - return _utils.is.promise(result) ? resolvePromise(result, cb) : _utils.is.iterator(result) ? resolveIterator(result, effectId, fn.name, cb) : cb(result); - } + genFun.prototype = Object.create(Gp); + return genFun; + }; - function runCPSEffect(_ref4, cb) { - var context = _ref4.context; - var fn = _ref4.fn; - var args = _ref4.args; + // Within the body of any async function, `await x` is transformed to + // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test + // `hasOwn.call(value, "__await")` to determine if the yielded value is + // meant to be awaited. + runtime.awrap = function(arg) { + return { __await: arg }; + }; - // CPS (ie node style functions) can define their own cancellation logic - // by setting cancel field on the cb + function AsyncIterator(generator) { + function invoke(method, arg, resolve, reject) { + var record = tryCatch(generator[method], generator, arg); + if (record.type === "throw") { + reject(record.arg); + } else { + var result = record.arg; + var value = result.value; + if (value && + typeof value === "object" && + hasOwn.call(value, "__await")) { + return Promise.resolve(value.__await).then(function(value) { + invoke("next", value, resolve, reject); + }, function(err) { + invoke("throw", err, resolve, reject); + }); + } - // catch synchronous failures; see #152 - try { - fn.apply(context, args.concat(function (err, res) { - return _utils.is.undef(err) ? cb(res) : cb(err, true); - })); - } catch (error) { - return cb(error, true); + return Promise.resolve(value).then(function(unwrapped) { + // When a yielded Promise is resolved, its final value becomes + // the .value of the Promise<{value,done}> result for the + // current iteration. If the Promise is rejected, however, the + // result for this iteration will be rejected with the same + // reason. Note that rejections of yielded Promises are not + // thrown back into the generator function, as is the case + // when an awaited Promise is rejected. This difference in + // behavior between yield and await is important, because it + // allows the consumer to decide what to do with the yielded + // rejection (swallow it and continue, manually .throw it back + // into the generator, abandon iteration, whatever). With + // await, by contrast, there is no opportunity to examine the + // rejection reason outside the generator function, so the + // only option is to throw it from the await expression, and + // let the generator function handle the exception. + result.value = unwrapped; + resolve(result); + }, reject); + } } - } - - function runForkEffect(_ref5, effectId, cb) { - var context = _ref5.context; - var fn = _ref5.fn; - var args = _ref5.args; - var detached = _ref5.detached; - - var result = void 0, - error = void 0, - _iterator = void 0; - - // we run the function, next we'll check if this is a generator function - // (generator is a function that returns an iterator) - // catch synchronous failures; see #152 and #441 - try { - result = fn.apply(context, args); - } catch (err) { - error = err; + if (typeof global.process === "object" && global.process.domain) { + invoke = global.process.domain.bind(invoke); } - // A generator function: i.e. returns an iterator - if (_utils.is.iterator(result)) { - _iterator = result; - } + var previousPromise; - // do not bubble up synchronous failures for detached forks - // instead create a failed task. See #152 and #441 - else { - _iterator = error ? (0, _utils.makeIterator)(function () { - throw error; - }) : (0, _utils.makeIterator)(function () { - var pc = void 0; - var eff = { done: false, value: result }; - var ret = function ret(value) { - return { done: true, value: value }; - }; - return function (arg) { - if (!pc) { - pc = true; - return eff; - } else { - return ret(arg); - } - }; - }()); + function enqueue(method, arg) { + function callInvokeWithMethodAndArg() { + return new Promise(function(resolve, reject) { + invoke(method, arg, resolve, reject); + }); } - _asap2.default.suspend(); - var task = proc(_iterator, subscribe, dispatch, getState, options, effectId, fn.name, detached ? null : _utils.noop); - if (detached) { - cb(task); - } else { - if (_iterator._isRunning) { - taskQueue.addTask(task); - cb(task); - } else if (_iterator._error) { - taskQueue.abort(_iterator._error); - } else { - cb(task); - } + return previousPromise = + // If enqueue has been called before, then we want to wait until + // all previous Promises have been resolved before calling invoke, + // so that results are always delivered in the correct order. If + // enqueue has not been called before, then it is important to + // call invoke immediately, without waiting on a callback to fire, + // so that the async generator function has the opportunity to do + // any necessary setup in a predictable way. This predictability + // is why the Promise constructor synchronously invokes its + // executor callback, and why async functions synchronously + // execute code before the first await. Since we implement simple + // async functions in terms of async generators, it is especially + // important to get this right, even though it requires care. + previousPromise ? previousPromise.then( + callInvokeWithMethodAndArg, + // Avoid propagating failures to Promises returned by later + // invocations of the iterator. + callInvokeWithMethodAndArg + ) : callInvokeWithMethodAndArg(); } - _asap2.default.flush(); - // Fork effects are non cancellables - } - function runJoinEffect(t, cb) { - if (t.isRunning()) { - (function () { - var joiner = { task: task, cb: cb }; - cb.cancel = function () { - return (0, _utils.remove)(t.joiners, joiner); - }; - t.joiners.push(joiner); - })(); - } else { - t.isAborted() ? cb(t.error(), true) : cb(t.result()); - } + // Define the unified helper method that is used to implement .next, + // .throw, and .return (see defineIteratorMethods). + this._invoke = enqueue; } - function runCancelEffect(task, cb) { - if (task.isRunning()) { - task.cancel(); - } - cb(); - // cancel effects are non cancellables - } + defineIteratorMethods(AsyncIterator.prototype); + AsyncIterator.prototype[asyncIteratorSymbol] = function () { + return this; + }; + runtime.AsyncIterator = AsyncIterator; + + // Note that simple async functions are implemented on top of + // AsyncIterator objects; they just return a Promise for the value of + // the final result produced by the iterator. + runtime.async = function(innerFn, outerFn, self, tryLocsList) { + var iter = new AsyncIterator( + wrap(innerFn, outerFn, self, tryLocsList) + ); - function runParallelEffect(effects, effectId, cb) { - if (!effects.length) { - return cb([]); - } + return runtime.isGeneratorFunction(outerFn) + ? iter // If outerFn is a generator, return the full iterator. + : iter.next().then(function(result) { + return result.done ? result.value : iter.next(); + }); + }; - var completedCount = 0; - var completed = void 0; - var results = Array(effects.length); + function makeInvokeMethod(innerFn, self, context) { + var state = GenStateSuspendedStart; - function checkEffectEnd() { - if (completedCount === results.length) { - completed = true; - cb(results); + return function invoke(method, arg) { + if (state === GenStateExecuting) { + throw new Error("Generator is already running"); } - } - var childCbs = effects.map(function (eff, idx) { - var chCbAtIdx = function chCbAtIdx(res, isErr) { - if (completed) { - return; - } - if (isErr || (0, _channel.isEnd)(res) || res === CHANNEL_END || res === TASK_CANCEL) { - cb.cancel(); - cb(res, isErr); - } else { - results[idx] = res; - completedCount++; - checkEffectEnd(); + if (state === GenStateCompleted) { + if (method === "throw") { + throw arg; } - }; - chCbAtIdx.cancel = _utils.noop; - return chCbAtIdx; - }); - cb.cancel = function () { - if (!completed) { - completed = true; - childCbs.forEach(function (chCb) { - return chCb.cancel(); - }); + // Be forgiving, per 25.3.3.3.3 of the spec: + // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume + return doneResult(); } - }; - - effects.forEach(function (eff, idx) { - return runEffect(eff, effectId, idx, childCbs[idx]); - }); - } - function runRaceEffect(effects, effectId, cb) { - var completed = void 0; - var keys = Object.keys(effects); - var childCbs = {}; + context.method = method; + context.arg = arg; - keys.forEach(function (key) { - var chCbAtKey = function chCbAtKey(res, isErr) { - if (completed) { - return; + while (true) { + var delegate = context.delegate; + if (delegate) { + var delegateResult = maybeInvokeDelegate(delegate, context); + if (delegateResult) { + if (delegateResult === ContinueSentinel) continue; + return delegateResult; + } } - if (isErr) { - // Race Auto cancellation - cb.cancel(); - cb(res, true); - } else if (!(0, _channel.isEnd)(res) && res !== CHANNEL_END && res !== TASK_CANCEL) { - cb.cancel(); - completed = true; - cb(_defineProperty({}, key, res)); - } - }; - chCbAtKey.cancel = _utils.noop; - childCbs[key] = chCbAtKey; - }); + if (context.method === "next") { + // Setting context._sent for legacy support of Babel's + // function.sent implementation. + context.sent = context._sent = context.arg; - cb.cancel = function () { - // prevents unnecessary cancellation - if (!completed) { - completed = true; - keys.forEach(function (key) { - return childCbs[key].cancel(); - }); - } - }; - keys.forEach(function (key) { - return runEffect(effects[key], effectId, key, childCbs[key]); - }); - } + } else if (context.method === "throw") { + if (state === GenStateSuspendedStart) { + state = GenStateCompleted; + throw context.arg; + } - function runSelectEffect(_ref6, cb) { - var selector = _ref6.selector; - var args = _ref6.args; + context.dispatchException(context.arg); - try { - var state = selector.apply(undefined, [getState()].concat(_toConsumableArray(args))); - cb(state); - } catch (error) { - cb(error, true); - } - } + } else if (context.method === "return") { + context.abrupt("return", context.arg); + } - function runChannelEffect(_ref7, cb) { - var pattern = _ref7.pattern; - var buffer = _ref7.buffer; + state = GenStateExecuting; - var match = matcher(pattern); - match.pattern = pattern; - cb((0, _channel.eventChannel)(subscribe, buffer || _buffers.buffers.fixed(), match)); - } + var record = tryCatch(innerFn, self, context); + if (record.type === "normal") { + // If an exception is thrown from innerFn, we leave state === + // GenStateExecuting and loop back for another invocation. + state = context.done + ? GenStateCompleted + : GenStateSuspendedYield; - function runCancelledEffect(data, cb) { - cb(!!mainTask.isCancelled); - } + if (record.arg === ContinueSentinel) { + continue; + } - function newTask(id, name, iterator, cont) { - var _done, _ref8, _mutatorMap; + return { + value: record.arg, + done: context.done + }; - iterator._deferredEnd = null; - return _ref8 = {}, _defineProperty(_ref8, _utils.TASK, true), _defineProperty(_ref8, 'id', id), _defineProperty(_ref8, 'name', name), _done = 'done', _mutatorMap = {}, _mutatorMap[_done] = _mutatorMap[_done] || {}, _mutatorMap[_done].get = function () { - if (iterator._deferredEnd) { - return iterator._deferredEnd.promise; - } else { - var def = (0, _utils.deferred)(); - iterator._deferredEnd = def; - if (!iterator._isRunning) { - iterator._error ? def.reject(iterator._error) : def.resolve(iterator._result); + } else if (record.type === "throw") { + state = GenStateCompleted; + // Dispatch the exception by looping back around to the + // context.dispatchException(context.arg) call above. + context.method = "throw"; + context.arg = record.arg; } - return def.promise; } - }, _defineProperty(_ref8, 'cont', cont), _defineProperty(_ref8, 'joiners', []), _defineProperty(_ref8, 'cancel', cancel), _defineProperty(_ref8, 'isRunning', function isRunning() { - return iterator._isRunning; - }), _defineProperty(_ref8, 'isCancelled', function isCancelled() { - return iterator._isCancelled; - }), _defineProperty(_ref8, 'isAborted', function isAborted() { - return iterator._isAborted; - }), _defineProperty(_ref8, 'result', function result() { - return iterator._result; - }), _defineProperty(_ref8, 'error', function error() { - return iterator._error; - }), _defineEnumerableProperties(_ref8, _mutatorMap), _ref8; + }; } - } - /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5))) - -/***/ }, -/* 8 */ -/***/ function(module, exports, __webpack_require__) { - - module.exports = __webpack_require__(6) - -/***/ }, -/* 9 */ -/***/ function(module, exports, __webpack_require__) { - - 'use strict'; - Object.defineProperty(exports, "__esModule", { - value: true - }); - exports.utils = exports.effects = exports.CANCEL = exports.delay = exports.takeLatest = exports.takeEvery = exports.buffers = exports.channel = exports.eventChannel = exports.END = exports.runSaga = undefined; + // Call delegate.iterator[context.method](context.arg) and handle the + // result, either by returning a { value, done } result from the + // delegate iterator, or by modifying context.method and context.arg, + // setting context.delegate to null, and returning the ContinueSentinel. + function maybeInvokeDelegate(delegate, context) { + var method = delegate.iterator[context.method]; + if (method === undefined) { + // A .throw or .return when the delegate iterator has no .throw + // method always terminates the yield* loop. + context.delegate = null; + + if (context.method === "throw") { + if (delegate.iterator.return) { + // If the delegate iterator has a return method, give it a + // chance to clean up. + context.method = "return"; + context.arg = undefined; + maybeInvokeDelegate(delegate, context); + + if (context.method === "throw") { + // If maybeInvokeDelegate(context) changed context.method from + // "return" to "throw", let that override the TypeError below. + return ContinueSentinel; + } + } - var _runSaga = __webpack_require__(12); + context.method = "throw"; + context.arg = new TypeError( + "The iterator does not provide a 'throw' method"); + } - Object.defineProperty(exports, 'runSaga', { - enumerable: true, - get: function get() { - return _runSaga.runSaga; - } - }); + return ContinueSentinel; + } - var _channel = __webpack_require__(2); + var record = tryCatch(method, delegate.iterator, context.arg); - Object.defineProperty(exports, 'END', { - enumerable: true, - get: function get() { - return _channel.END; - } - }); - Object.defineProperty(exports, 'eventChannel', { - enumerable: true, - get: function get() { - return _channel.eventChannel; - } - }); - Object.defineProperty(exports, 'channel', { - enumerable: true, - get: function get() { - return _channel.channel; - } - }); + if (record.type === "throw") { + context.method = "throw"; + context.arg = record.arg; + context.delegate = null; + return ContinueSentinel; + } - var _buffers = __webpack_require__(4); + var info = record.arg; - Object.defineProperty(exports, 'buffers', { - enumerable: true, - get: function get() { - return _buffers.buffers; - } - }); - - var _sagaHelpers = __webpack_require__(13); + if (! info) { + context.method = "throw"; + context.arg = new TypeError("iterator result is not an object"); + context.delegate = null; + return ContinueSentinel; + } - Object.defineProperty(exports, 'takeEvery', { - enumerable: true, - get: function get() { - return _sagaHelpers.takeEvery; - } - }); - Object.defineProperty(exports, 'takeLatest', { - enumerable: true, - get: function get() { - return _sagaHelpers.takeLatest; - } - }); + if (info.done) { + // Assign the result of the finished delegate to the temporary + // variable specified by delegate.resultName (see delegateYield). + context[delegate.resultName] = info.value; + + // Resume execution at the desired location (see delegateYield). + context.next = delegate.nextLoc; + + // If context.method was "throw" but the delegate handled the + // exception, let the outer generator proceed normally. If + // context.method was "next", forget context.arg since it has been + // "consumed" by the delegate iterator. If context.method was + // "return", allow the original .return call to continue in the + // outer generator. + if (context.method !== "return") { + context.method = "next"; + context.arg = undefined; + } - var _utils = __webpack_require__(1); + } else { + // Re-yield the result returned by the delegate method. + return info; + } - Object.defineProperty(exports, 'delay', { - enumerable: true, - get: function get() { - return _utils.delay; + // The delegate iterator is finished, so forget it and continue with + // the outer generator. + context.delegate = null; + return ContinueSentinel; } - }); - Object.defineProperty(exports, 'CANCEL', { - enumerable: true, - get: function get() { - return _utils.CANCEL; - } - }); - - var _middleware = __webpack_require__(11); - - var _middleware2 = _interopRequireDefault(_middleware); - - var _effects = __webpack_require__(6); - - var effects = _interopRequireWildcard(_effects); - - var _utils2 = __webpack_require__(14); - var utils = _interopRequireWildcard(_utils2); + // Define Generator.prototype.{next,throw,return} in terms of the + // unified ._invoke helper method. + defineIteratorMethods(Gp); - function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + Gp[toStringTagSymbol] = "Generator"; - function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + // A Generator should always return itself as the iterator object when the + // @@iterator function is called on it. Some browsers' implementations of the + // iterator prototype chain incorrectly implement this, causing the Generator + // object to not be returned from this call. This ensures that doesn't happen. + // See https://github.com/facebook/regenerator/issues/274 for more details. + Gp[iteratorSymbol] = function() { + return this; + }; - exports.default = _middleware2.default; - exports.effects = effects; - exports.utils = utils; + Gp.toString = function() { + return "[object Generator]"; + }; -/***/ }, -/* 10 */ -/***/ function(module, exports) { + function pushTryEntry(locs) { + var entry = { tryLoc: locs[0] }; - "use strict"; + if (1 in locs) { + entry.catchLoc = locs[1]; + } - Object.defineProperty(exports, "__esModule", { - value: true - }); - exports.default = asap; - var queue = []; - var isSuspended = false; - - function asap(task) { - if (!isSuspended) { - isSuspended = true; - queue.push(task); - asap.flush(); - } else { - queue.push(task); - } - } + if (2 in locs) { + entry.finallyLoc = locs[2]; + entry.afterLoc = locs[3]; + } - asap.suspend = function () { - return isSuspended = true; - }; - asap.flush = function () { - var nextTask = void 0; - while (nextTask = queue.shift()) { - nextTask(); + this.tryEntries.push(entry); } - isSuspended = false; - }; - -/***/ }, -/* 11 */ -/***/ function(module, exports, __webpack_require__) { - - /* WEBPACK VAR INJECTION */(function(process) {'use strict'; - - Object.defineProperty(exports, "__esModule", { - value: true - }); - exports.default = sagaMiddlewareFactory; - var _utils = __webpack_require__(1); - - var _proc = __webpack_require__(7); - - var _proc2 = _interopRequireDefault(_proc); - - var _channel = __webpack_require__(2); - - function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - - function sagaMiddlewareFactory() { - var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; - - var runSagaDynamically = void 0; - - if (_utils.is.func(options)) { - if (process.env.NODE_ENV === 'production') { - throw new Error('Saga middleware no longer accept Generator functions. Use sagaMiddleware.run instead'); - } else { - throw new Error('You passed a function to the Saga middleware. You are likely trying to start a Saga by directly passing it to the middleware. This is no longer possible starting from 0.10.0. To run a Saga, you must do it dynamically AFTER mounting the middleware into the store.\n Example:\n import createSagaMiddleware from \'redux-saga\'\n ... other imports\n\n const sagaMiddleware = createSagaMiddleware()\n const store = createStore(reducer, applyMiddleware(sagaMiddleware))\n sagaMiddleware.run(saga, ...args)\n '); - } + function resetTryEntry(entry) { + var record = entry.completion || {}; + record.type = "normal"; + delete record.arg; + entry.completion = record; } - if (options.logger && !_utils.is.func(options.logger)) { - throw new Error('`options.logger` passed to the Saga middleware is not a function!'); + function Context(tryLocsList) { + // The root entry object (effectively a try statement without a catch + // or a finally block) gives us a place to store values thrown from + // locations where there is no enclosing try statement. + this.tryEntries = [{ tryLoc: "root" }]; + tryLocsList.forEach(pushTryEntry, this); + this.reset(true); } - function sagaMiddleware(_ref) { - var getState = _ref.getState; - var dispatch = _ref.dispatch; - - runSagaDynamically = runSaga; - var sagaEmitter = (0, _channel.emitter)(); - - function runSaga(saga) { - for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { - args[_key - 1] = arguments[_key]; - } - - return (0, _proc2.default)(saga.apply(undefined, args), sagaEmitter.subscribe, dispatch, getState, options, 0, saga.name); + runtime.keys = function(object) { + var keys = []; + for (var key in object) { + keys.push(key); } + keys.reverse(); + + // Rather than returning an object with a next method, we keep + // things simple and return the next function itself. + return function next() { + while (keys.length) { + var key = keys.pop(); + if (key in object) { + next.value = key; + next.done = false; + return next; + } + } - return function (next) { - return function (action) { - var result = next(action); // hit reducers - sagaEmitter.emit(action); - return result; - }; + // To avoid creating an additional object, we just hang the .value + // and .done properties off the next function object itself. This + // also ensures that the minifier will not anonymize the function. + next.done = true; + return next; }; - } - - sagaMiddleware.run = function (saga) { - for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { - args[_key2 - 1] = arguments[_key2]; - } - - (0, _utils.check)(runSagaDynamically, _utils.is.notUndef, 'Before running a Saga, you must mount the Saga middleware on the Store using applyMiddleware'); - (0, _utils.check)(saga, _utils.is.func, 'sagaMiddleware.run(saga, ...args): saga argument must be a Generator function!'); - return runSagaDynamically.apply(undefined, [saga].concat(args)); }; - return sagaMiddleware; - } - /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5))) - -/***/ }, -/* 12 */ -/***/ function(module, exports, __webpack_require__) { - - 'use strict'; - - Object.defineProperty(exports, "__esModule", { - value: true - }); - exports.runSaga = runSaga; + function values(iterable) { + if (iterable) { + var iteratorMethod = iterable[iteratorSymbol]; + if (iteratorMethod) { + return iteratorMethod.call(iterable); + } - var _utils = __webpack_require__(1); + if (typeof iterable.next === "function") { + return iterable; + } - var _proc = __webpack_require__(7); + if (!isNaN(iterable.length)) { + var i = -1, next = function next() { + while (++i < iterable.length) { + if (hasOwn.call(iterable, i)) { + next.value = iterable[i]; + next.done = false; + return next; + } + } - var _proc2 = _interopRequireDefault(_proc); + next.value = undefined; + next.done = true; - function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - - function runSaga(iterator, _ref) { - var subscribe = _ref.subscribe; - var dispatch = _ref.dispatch; - var getState = _ref.getState; - var sagaMonitor = _ref.sagaMonitor; - var logger = _ref.logger; + return next; + }; + return next.next = next; + } + } - (0, _utils.check)(iterator, _utils.is.iterator, "runSaga must be called on an iterator"); + // Return an iterator with no values. + return { next: doneResult }; + } + runtime.values = values; - return (0, _proc2.default)(iterator, subscribe, dispatch, getState, { sagaMonitor: sagaMonitor, logger: logger }); - } + function doneResult() { + return { value: undefined, done: true }; + } -/***/ }, -/* 13 */ -/***/ function(module, exports, __webpack_require__) { + Context.prototype = { + constructor: Context, - 'use strict'; + reset: function(skipTempReset) { + this.prev = 0; + this.next = 0; + // Resetting context._sent for legacy support of Babel's + // function.sent implementation. + this.sent = this._sent = undefined; + this.done = false; + this.delegate = null; - Object.defineProperty(exports, "__esModule", { - value: true - }); + this.method = "next"; + this.arg = undefined; - var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); + this.tryEntries.forEach(resetTryEntry); - exports.takeEvery = takeEvery; - exports.takeLatest = takeLatest; + if (!skipTempReset) { + for (var name in this) { + // Not sure about the optimal order of these conditions: + if (name.charAt(0) === "t" && + hasOwn.call(this, name) && + !isNaN(+name.slice(1))) { + this[name] = undefined; + } + } + } + }, - var _channel = __webpack_require__(2); + stop: function() { + this.done = true; - var _utils = __webpack_require__(1); + var rootEntry = this.tryEntries[0]; + var rootRecord = rootEntry.completion; + if (rootRecord.type === "throw") { + throw rootRecord.arg; + } - var _io = __webpack_require__(3); + return this.rval; + }, - var done = { done: true, value: undefined }; - var qEnd = {}; + dispatchException: function(exception) { + if (this.done) { + throw exception; + } - function fsmIterator(fsm, q0) { - var name = arguments.length <= 2 || arguments[2] === undefined ? 'iterator' : arguments[2]; + var context = this; + function handle(loc, caught) { + record.type = "throw"; + record.arg = exception; + context.next = loc; + + if (caught) { + // If the dispatched exception was caught by a catch block, + // then let that catch block handle the exception normally. + context.method = "next"; + context.arg = undefined; + } - var updateState = void 0, - qNext = q0; + return !! caught; + } - function next(arg, error) { - if (qNext === qEnd) { - return done; - } + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + var record = entry.completion; - if (error) { - qNext = qEnd; - throw error; - } else { - updateState && updateState(arg); + if (entry.tryLoc === "root") { + // Exception thrown outside of any try block that could handle + // it, so set the completion value of the entire function to + // throw the exception. + return handle("end"); + } - var _fsm$qNext = fsm[qNext](); + if (entry.tryLoc <= this.prev) { + var hasCatch = hasOwn.call(entry, "catchLoc"); + var hasFinally = hasOwn.call(entry, "finallyLoc"); - var _fsm$qNext2 = _slicedToArray(_fsm$qNext, 3); + if (hasCatch && hasFinally) { + if (this.prev < entry.catchLoc) { + return handle(entry.catchLoc, true); + } else if (this.prev < entry.finallyLoc) { + return handle(entry.finallyLoc); + } - var q = _fsm$qNext2[0]; - var output = _fsm$qNext2[1]; - var _updateState = _fsm$qNext2[2]; + } else if (hasCatch) { + if (this.prev < entry.catchLoc) { + return handle(entry.catchLoc, true); + } - qNext = q; - updateState = _updateState; - return qNext === qEnd ? done : output; - } - } + } else if (hasFinally) { + if (this.prev < entry.finallyLoc) { + return handle(entry.finallyLoc); + } - return (0, _utils.makeIterator)(next, function (error) { - return next(null, error); - }, name); - } + } else { + throw new Error("try statement without catch or finally"); + } + } + } + }, - function safeName(pattern) { - if (Array.isArray(pattern)) { - return String(pattern.map(function (entry) { - return String(entry); - })); - } else { - return String(pattern); - } - } + abrupt: function(type, arg) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + if (entry.tryLoc <= this.prev && + hasOwn.call(entry, "finallyLoc") && + this.prev < entry.finallyLoc) { + var finallyEntry = entry; + break; + } + } - function takeEvery(pattern, worker) { - for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { - args[_key - 2] = arguments[_key]; - } + if (finallyEntry && + (type === "break" || + type === "continue") && + finallyEntry.tryLoc <= arg && + arg <= finallyEntry.finallyLoc) { + // Ignore the finally entry if control is not jumping to a + // location outside the try/catch block. + finallyEntry = null; + } - var yTake = { done: false, value: (0, _io.take)(pattern) }; - var yFork = function yFork(ac) { - return { done: false, value: _io.fork.apply(undefined, [worker].concat(args, [ac])) }; - }; + var record = finallyEntry ? finallyEntry.completion : {}; + record.type = type; + record.arg = arg; - var action = void 0, - setAction = function setAction(ac) { - return action = ac; - }; + if (finallyEntry) { + this.method = "next"; + this.next = finallyEntry.finallyLoc; + return ContinueSentinel; + } - return fsmIterator({ - q1: function q1() { - return ['q2', yTake, setAction]; + return this.complete(record); }, - q2: function q2() { - return action === _channel.END ? [qEnd] : ['q1', yFork(action)]; - } - }, 'q1', 'takeEvery(' + safeName(pattern) + ', ' + worker.name + ')'); - } - - function takeLatest(pattern, worker) { - for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { - args[_key2 - 2] = arguments[_key2]; - } - var yTake = { done: false, value: (0, _io.take)(pattern) }; - var yFork = function yFork(ac) { - return { done: false, value: _io.fork.apply(undefined, [worker].concat(args, [ac])) }; - }; - var yCancel = function yCancel(task) { - return { done: false, value: (0, _io.cancel)(task) }; - }; + complete: function(record, afterLoc) { + if (record.type === "throw") { + throw record.arg; + } - var task = void 0, - action = void 0; - var setTask = function setTask(t) { - return task = t; - }; - var setAction = function setAction(ac) { - return action = ac; - }; + if (record.type === "break" || + record.type === "continue") { + this.next = record.arg; + } else if (record.type === "return") { + this.rval = this.arg = record.arg; + this.method = "return"; + this.next = "end"; + } else if (record.type === "normal" && afterLoc) { + this.next = afterLoc; + } - return fsmIterator({ - q1: function q1() { - return ['q2', yTake, setAction]; - }, - q2: function q2() { - return action === _channel.END ? [qEnd] : task ? ['q3', yCancel(task)] : ['q1', yFork(action), setTask]; + return ContinueSentinel; }, - q3: function q3() { - return ['q1', yFork(action), setTask]; - } - }, 'q1', 'takeLatest(' + safeName(pattern) + ', ' + worker.name + ')'); - } - -/***/ }, -/* 14 */ -/***/ function(module, exports, __webpack_require__) { - - 'use strict'; - Object.defineProperty(exports, "__esModule", { - value: true - }); + finish: function(finallyLoc) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + if (entry.finallyLoc === finallyLoc) { + this.complete(entry.completion, entry.afterLoc); + resetTryEntry(entry); + return ContinueSentinel; + } + } + }, - var _utils = __webpack_require__(1); + "catch": function(tryLoc) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + if (entry.tryLoc === tryLoc) { + var record = entry.completion; + if (record.type === "throw") { + var thrown = record.arg; + resetTryEntry(entry); + } + return thrown; + } + } - Object.defineProperty(exports, 'TASK', { - enumerable: true, - get: function get() { - return _utils.TASK; - } - }); - Object.defineProperty(exports, 'noop', { - enumerable: true, - get: function get() { - return _utils.noop; - } - }); - Object.defineProperty(exports, 'is', { - enumerable: true, - get: function get() { - return _utils.is; - } - }); - Object.defineProperty(exports, 'deferred', { - enumerable: true, - get: function get() { - return _utils.deferred; - } - }); - Object.defineProperty(exports, 'arrayOfDeffered', { - enumerable: true, - get: function get() { - return _utils.arrayOfDeffered; - } - }); - Object.defineProperty(exports, 'createMockTask', { - enumerable: true, - get: function get() { - return _utils.createMockTask; - } - }); + // The context.catch method must only be called with a location + // argument that corresponds to a known catch block. + throw new Error("illegal catch attempt"); + }, - var _io = __webpack_require__(3); + delegateYield: function(iterable, resultName, nextLoc) { + this.delegate = { + iterator: values(iterable), + resultName: resultName, + nextLoc: nextLoc + }; - Object.defineProperty(exports, 'asEffect', { - enumerable: true, - get: function get() { - return _io.asEffect; - } - }); + if (this.method === "next") { + // Deliberately forget the last sent value so that we don't + // accidentally pass it on to the delegate. + this.arg = undefined; + } -/***/ } + return ContinueSentinel; + } + }; + })( + // Among the various tricks for obtaining a reference to the global + // object, this seems to be the most reliable technique that does not + // use indirect eval (which violates Content Security Policy). + typeof global === "object" ? global : + typeof window === "object" ? window : + typeof self === "object" ? self : this + ); + + /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) + +/***/ }) /******/ ]) }); ; \ No newline at end of file diff --git a/modules/index.js b/modules/index.js index e693235..34633dd 100644 --- a/modules/index.js +++ b/modules/index.js @@ -5,12 +5,27 @@ Object.defineProperty(exports, "__esModule", { }); exports.newKey = exports.VALUE = exports.CHILD_MOVED = exports.CHILD_CHANGED = exports.CHILD_REMOVED = exports.CHILD_ADDED = undefined; -var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); +var _getIterator2 = require('babel-runtime/core-js/get-iterator'); + +var _getIterator3 = _interopRequireDefault(_getIterator2); + +var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray'); + +var _slicedToArray3 = _interopRequireDefault(_slicedToArray2); + +var _regenerator = require('babel-runtime/regenerator'); + +var _regenerator2 = _interopRequireDefault(_regenerator); + +var _defineProperty2 = require('babel-runtime/helpers/defineProperty'); + +var _defineProperty3 = _interopRequireDefault(_defineProperty2); exports.get = get; exports.getAll = getAll; exports.create = create; exports.update = update; +exports.updateAll = updateAll; exports.push = push; exports.remove = remove; exports.sync = sync; @@ -19,9 +34,9 @@ var _reduxSaga = require('redux-saga'); var _effects = require('redux-saga/effects'); -var _marked = [get, getAll, create, update, push, remove, runSync, sync].map(regeneratorRuntime.mark); +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +var _marked = [get, getAll, create, update, updateAll, push, remove, runSync, sync].map(_regenerator2.default.mark); var CHILD_ADDED = exports.CHILD_ADDED = 'child_added'; var CHILD_REMOVED = exports.CHILD_REMOVED = 'child_removed'; @@ -32,12 +47,12 @@ var VALUE = exports.VALUE = 'value'; var EVENT_TYPES = [CHILD_ADDED, CHILD_REMOVED, CHILD_CHANGED, CHILD_MOVED, VALUE]; var newOpts = function newOpts() { - var name = arguments.length <= 0 || arguments[0] === undefined ? 'data' : arguments[0]; + var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'data'; var opts = {}; var chan = (0, _reduxSaga.eventChannel)(function (emit) { opts.handler = function (obj) { - emit(_defineProperty({}, name, obj)); + emit((0, _defineProperty3.default)({}, name, obj)); }; return function () {}; }); @@ -62,7 +77,7 @@ var newKey = exports.newKey = function newKey(path) { */ function get(path, key) { var ref, data; - return regeneratorRuntime.wrap(function get$(_context) { + return _regenerator2.default.wrap(function get$(_context) { while (1) { switch (_context.prev = _context.next) { case 0: @@ -94,7 +109,7 @@ function get(path, key) { */ function getAll(path) { var ref, data; - return regeneratorRuntime.wrap(function getAll$(_context2) { + return _regenerator2.default.wrap(function getAll$(_context2) { while (1) { switch (_context2.prev = _context2.next) { case 0: @@ -134,7 +149,7 @@ function getAll(path) { function create(path, fn) { var key, payload, opts, ref, _ref, _ref2, _, error; - return regeneratorRuntime.wrap(function create$(_context3) { + return _regenerator2.default.wrap(function create$(_context3) { while (1) { switch (_context3.prev = _context3.next) { case 0: @@ -155,7 +170,7 @@ function create(path, fn) { case 10: _ref = _context3.sent; - _ref2 = _slicedToArray(_ref, 2); + _ref2 = (0, _slicedToArray3.default)(_ref, 2); _ = _ref2[0]; error = _ref2[1].error; return _context3.abrupt('return', error); @@ -182,7 +197,7 @@ function create(path, fn) { function update(path, key, payload) { var opts, ref, _ref3, _ref4, _, error; - return regeneratorRuntime.wrap(function update$(_context4) { + return _regenerator2.default.wrap(function update$(_context4) { while (1) { switch (_context4.prev = _context4.next) { case 0: @@ -205,7 +220,7 @@ function update(path, key, payload) { case 8: _ref3 = _context4.sent; - _ref4 = _slicedToArray(_ref3, 2); + _ref4 = (0, _slicedToArray3.default)(_ref3, 2); _ = _ref4[0]; error = _ref4[1].error; return _context4.abrupt('return', error); @@ -218,6 +233,62 @@ function update(path, key, payload) { }, _marked[3], this); } +/** + * Updates existing data in the database with `update()` + * + * @param path + * @param key + * @param payload + * @returns {*} + * * import { updateAll } from 'firebase-saga'; + * + * const postDate = { title: 'My Second Post', + * body: 'Second post details', + * timestamp: +new Date }; + * const updates = {}; + * updates['/posts/' + newPostKey] = postData; + * updates['/user-posts/' + uid + '/' + newPostKey] = postData; + * yield call(updateAll, 'posts', updates); + */ +function updateAll(path, payload) { + var opts, ref, _ref5, _ref6, _, error; + + return _regenerator2.default.wrap(function updateAll$(_context5) { + while (1) { + switch (_context5.prev = _context5.next) { + case 0: + if (!(typeof payload === 'function')) { + _context5.next = 4; + break; + } + + _context5.next = 3; + return (0, _effects.call)(payload); + + case 3: + payload = _context5.sent; + + case 4: + opts = newOpts('error'); + ref = firebase.database().ref(path); + _context5.next = 8; + return [(0, _effects.call)([ref, ref.update], payload, opts.handler), (0, _effects.take)(opts)]; + + case 8: + _ref5 = _context5.sent; + _ref6 = (0, _slicedToArray3.default)(_ref5, 2); + _ = _ref6[0]; + error = _ref6[1].error; + return _context5.abrupt('return', error); + + case 13: + case 'end': + return _context5.stop(); + } + } + }, _marked[4], this); +} + /** * Generates a new child location using a unique key * @@ -235,51 +306,51 @@ function update(path, key, payload) { *); */ function push(path, fn) { - var getKey = arguments.length <= 2 || arguments[2] === undefined ? false : arguments[2]; + var getKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; - var key, payload, opts, ref, _ref5, _ref6, _, error; + var key, payload, opts, ref, _ref7, _ref8, _, error; - return regeneratorRuntime.wrap(function push$(_context5) { + return _regenerator2.default.wrap(function push$(_context6) { while (1) { - switch (_context5.prev = _context5.next) { + switch (_context6.prev = _context6.next) { case 0: - _context5.next = 2; + _context6.next = 2; return (0, _effects.call)(newKey, path); case 2: - key = _context5.sent; - _context5.next = 5; + key = _context6.sent; + _context6.next = 5; return (0, _effects.call)(fn, key); case 5: - payload = _context5.sent; + payload = _context6.sent; opts = newOpts('error'); ref = firebase.database().ref(path); - _context5.next = 10; + _context6.next = 10; return [(0, _effects.call)([ref, ref.push], payload, opts.handler), (0, _effects.take)(opts)]; case 10: - _ref5 = _context5.sent; - _ref6 = _slicedToArray(_ref5, 2); - _ = _ref6[0]; - error = _ref6[1].error; + _ref7 = _context6.sent; + _ref8 = (0, _slicedToArray3.default)(_ref7, 2); + _ = _ref8[0]; + error = _ref8[1].error; if (!(getKey && error === undefined)) { - _context5.next = 16; + _context6.next = 16; break; } - return _context5.abrupt('return', key); + return _context6.abrupt('return', key); case 16: - return _context5.abrupt('return', error); + return _context6.abrupt('return', error); case 17: case 'end': - return _context5.stop(); + return _context6.stop(); } } - }, _marked[4], this); + }, _marked[5], this); } /** @@ -310,68 +381,68 @@ function push(path, fn) { * yield call(remove, 'posts', '1234') */ function remove(path, key) { - var opts, ref, _ref7, _ref8, _, error; + var opts, ref, _ref9, _ref10, _, error; - return regeneratorRuntime.wrap(function remove$(_context6) { + return _regenerator2.default.wrap(function remove$(_context7) { while (1) { - switch (_context6.prev = _context6.next) { + switch (_context7.prev = _context7.next) { case 0: opts = newOpts('error'); ref = firebase.database().ref(path + '/' + key); - _context6.next = 4; + _context7.next = 4; return [(0, _effects.call)([ref, ref.remove], opts.handler), (0, _effects.take)(opts)]; case 4: - _ref7 = _context6.sent; - _ref8 = _slicedToArray(_ref7, 2); - _ = _ref8[0]; - error = _ref8[1].error; - return _context6.abrupt('return', error); + _ref9 = _context7.sent; + _ref10 = (0, _slicedToArray3.default)(_ref9, 2); + _ = _ref10[0]; + error = _ref10[1].error; + return _context7.abrupt('return', error); case 9: case 'end': - return _context6.stop(); + return _context7.stop(); } } - }, _marked[5], this); + }, _marked[6], this); } function runSync(ref, eventType, actionCreator) { - var opts, _ref9, data; + var opts, _ref11, data; - return regeneratorRuntime.wrap(function runSync$(_context7) { + return _regenerator2.default.wrap(function runSync$(_context8) { while (1) { - switch (_context7.prev = _context7.next) { + switch (_context8.prev = _context8.next) { case 0: opts = newOpts(); - _context7.next = 3; + _context8.next = 3; return (0, _effects.call)([ref, ref.on], eventType, opts.handler); case 3: if (!true) { - _context7.next = 12; + _context8.next = 12; break; } - _context7.next = 6; + _context8.next = 6; return (0, _effects.take)(opts); case 6: - _ref9 = _context7.sent; - data = _ref9.data; - _context7.next = 10; + _ref11 = _context8.sent; + data = _ref11.data; + _context8.next = 10; return (0, _effects.put)(actionCreator({ key: data.key, value: data.val() })); case 10: - _context7.next = 3; + _context8.next = 3; break; case 12: case 'end': - return _context7.stop(); + return _context8.stop(); } } - }, _marked[6], this); + }, _marked[7], this); } /** @@ -391,25 +462,25 @@ function runSync(ref, eventType, actionCreator) { *} */ function sync(path) { - var mapEventToAction = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1]; + var mapEventToAction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; var limit = arguments[2]; var ref, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, type, action; - return regeneratorRuntime.wrap(function sync$(_context8) { + return _regenerator2.default.wrap(function sync$(_context9) { while (1) { - switch (_context8.prev = _context8.next) { + switch (_context9.prev = _context9.next) { case 0: ref = typeof limit === 'number' ? firebase.database().ref(path).limitToLast(limit) : firebase.database().ref(path); _iteratorNormalCompletion = true; _didIteratorError = false; _iteratorError = undefined; - _context8.prev = 4; - _iterator = EVENT_TYPES[Symbol.iterator](); + _context9.prev = 4; + _iterator = (0, _getIterator3.default)(EVENT_TYPES); case 6: if (_iteratorNormalCompletion = (_step = _iterator.next()).done) { - _context8.next = 15; + _context9.next = 15; break; } @@ -417,56 +488,56 @@ function sync(path) { action = mapEventToAction[type]; if (!(typeof action === 'function')) { - _context8.next = 12; + _context9.next = 12; break; } - _context8.next = 12; + _context9.next = 12; return (0, _effects.fork)(runSync, ref, type, action); case 12: _iteratorNormalCompletion = true; - _context8.next = 6; + _context9.next = 6; break; case 15: - _context8.next = 21; + _context9.next = 21; break; case 17: - _context8.prev = 17; - _context8.t0 = _context8['catch'](4); + _context9.prev = 17; + _context9.t0 = _context9['catch'](4); _didIteratorError = true; - _iteratorError = _context8.t0; + _iteratorError = _context9.t0; case 21: - _context8.prev = 21; - _context8.prev = 22; + _context9.prev = 21; + _context9.prev = 22; if (!_iteratorNormalCompletion && _iterator.return) { _iterator.return(); } case 24: - _context8.prev = 24; + _context9.prev = 24; if (!_didIteratorError) { - _context8.next = 27; + _context9.next = 27; break; } throw _iteratorError; case 27: - return _context8.finish(24); + return _context9.finish(24); case 28: - return _context8.finish(21); + return _context9.finish(21); case 29: case 'end': - return _context8.stop(); + return _context9.stop(); } } - }, _marked[7], this, [[4, 17, 21, 29], [22,, 24, 28]]); + }, _marked[8], this, [[4, 17, 21, 29], [22,, 24, 28]]); } \ No newline at end of file diff --git a/package.json b/package.json index b07304d..6d609f7 100644 --- a/package.json +++ b/package.json @@ -1,43 +1,43 @@ { - "name": "firebase-saga", - "version": "1.2.0", - "description": "A library for connecting Redux saga middleware to Firebase.", - "main": "dist/ReactProxy.js", - "scripts": { - "build": "rimraf modules dist && NODE_ENV=babel-es2015 webpack && NODE_ENV=babel-es2015 babel src --out-dir modules", - "docs": "./node_modules/.bin/esdoc -c esdoc.json; open ./docs/index.html", - "prepublish": "npm run build" - }, - "repository": { - "type": "git", - "url": "git+https://github.com/szaranger/firebase-saga.git" - }, - "keywords": [ - "firebase", - "saga", - "redux" - ], - "author": "Sean Amarasinghe ", - "license": "MIT", - "bugs": { - "url": "https://github.com/szaranger/firebase-saga/issues" - }, - "homepage": "https://github.com/szaranger/firebase-saga#readme", - "devDependencies": { - "babel-cli": "^6.3.17", - "babel-core": "^6.3.21", - "babel-loader": "^6.2.0", - "babel-plugin-transform-runtime": "^6.15.0", - "babel-preset-es2015": "^6.6.0", - "babel-preset-react": "^6.5.0", - "esdoc": "^0.4.7", - "esdoc-es7-plugin": "0.0.3", - "expect": "^1.9.0", - "mocha": "^2.2.4", - "rimraf": "^2.4.2", - "webpack": "^1.13.1" - }, - "peerDependencies": { - "redux-saga": ">=0.15.1", - } + "name": "firebase-saga", + "version": "1.2.0", + "description": "A library for connecting Redux saga middleware to Firebase.", + "main": "dist/ReactProxy.js", + "scripts": { + "build": "rimraf modules dist && NODE_ENV=babel-es2015 webpack && NODE_ENV=babel-es2015 babel src --out-dir modules", + "docs": "./node_modules/.bin/esdoc -c esdoc.json; open ./docs/index.html", + "prepublish": "npm run build" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/szaranger/firebase-saga.git" + }, + "keywords": [ + "firebase", + "saga", + "redux" + ], + "author": "Sean Amarasinghe ", + "license": "MIT", + "bugs": { + "url": "https://github.com/szaranger/firebase-saga/issues" + }, + "homepage": "https://github.com/szaranger/firebase-saga#readme", + "devDependencies": { + "babel-cli": "^6.3.17", + "babel-core": "^6.3.21", + "babel-loader": "^6.2.0", + "babel-plugin-transform-runtime": "^6.23.0", + "babel-preset-es2015": "^6.6.0", + "babel-preset-react": "^6.5.0", + "esdoc": "^0.4.7", + "esdoc-es7-plugin": "0.0.3", + "expect": "^1.9.0", + "mocha": "^2.2.4", + "rimraf": "^2.4.2", + "webpack": "^1.13.1" + }, + "peerDependencies": { + "redux-saga": ">=0.15.1" + } }